package ferramentas;

import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import javax.mail.MessagingException;
import pessoal.*;
import tela.eventociar.NumeroDeInscritos;
import tela.iptsp.modelo.InscritoIPTSP;

/**
 *
 * @author kako
 */
public class Query {

    String wstoken = CFG.WS_TOKEN;
    String testMoodle = CFG.WS_MOODLE_CIAR;

    public Query() {
    }

    public Query(boolean safe) {
    }

    public ArrayList<String[]> getCursos(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<String[]> lista = new ArrayList<String[]>();
            String sql = getSQLCursos();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                String[] curso = new String[2];
                curso[0] = "" + result.getInt("numero");
                curso[1] = result.getString("nome");
                lista.add(curso);
            }
            Conexao.close(conexao, query, result);
            return lista;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirUsuario(Usuario u) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirUsuario();
            PreparedStatement query = conexao.prepareStatement(sql);
            int indice = 1;
            query.setString(indice++, u.getCpf());
            query.setString(indice++, u.getNome());
            query.setString(indice++, u.getSobrenome());
            query.setDate(indice++, new java.sql.Date(u.getNascimento().getTime()));
            query.setString(indice++, String.valueOf(u.getSexo()));
            query.setBoolean(indice++, u.getEnsinoMedio());
            query.setBoolean(indice++, u.getGraduacao());
            query.setBoolean(indice++, u.getEspecializacao());
            query.setBoolean(indice++, u.getMestrado());
            query.setBoolean(indice++, u.getDoutorado());
            query.setString(indice++, u.getEmail());
            query.setString(indice++, u.getDdd());
            query.setString(indice++, u.getTelefone());
            query.setString(indice++, u.getSenha());
            query.setString(indice++, u.getEndereco().getCep());
            query.setString(indice++, u.getEndereco().getLogradouro());
            query.setString(indice++, u.getEndereco().getNumero());
            query.setString(indice++, u.getEndereco().getBairro());
            query.setString(indice++, u.getEndereco().getCidade());
            query.setString(indice++, u.getEndereco().getEstado());
            query.setInt(indice++, u.getEndereco().getEstadoId());
            query.setInt(indice++, u.getEndereco().getCidadeId());
            query.execute();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizarUsuario(Usuario u) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLAtualizarUsuario();
            PreparedStatement query = conexao.prepareStatement(sql);
            int indice = 1;
            query.setString(indice++, u.getNome());
            query.setString(indice++, u.getSobrenome());
            query.setDate(indice++, new java.sql.Date(u.getNascimento().getTime()));
            query.setString(indice++, String.valueOf(u.getSexo()));
            query.setBoolean(indice++, u.getEnsinoMedio());
            query.setBoolean(indice++, u.getGraduacao());
            query.setBoolean(indice++, u.getEspecializacao());
            query.setBoolean(indice++, u.getMestrado());
            query.setBoolean(indice++, u.getDoutorado());
            query.setString(indice++, u.getEmail());
            query.setString(indice++, u.getDdd());
            query.setString(indice++, u.getTelefone());
            query.setString(indice++, u.getSenha());
            query.setString(indice++, u.getEndereco().getCep());
            query.setString(indice++, u.getEndereco().getLogradouro());
            query.setString(indice++, u.getEndereco().getNumero());
            query.setString(indice++, u.getEndereco().getBairro());
            query.setString(indice++, u.getEndereco().getCidade());
            query.setString(indice++, u.getEndereco().getEstado());
            query.setInt(indice++, u.getEndereco().getEstadoId());
            query.setInt(indice++, u.getEndereco().getCidadeId());
            query.setString(indice++, u.getCpf());
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizarEmailUsuario(String cpf, String emailNovo) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLAtualizarEmailUsuario();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, emailNovo);
            query.setString(2, cpf);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Polo> getPolos() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM polo ORDER BY nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            ArrayList<Polo> polos = new ArrayList<Polo>();
            while (resultado.next()) {
                Polo p = new Polo(resultado.getInt("numero"), resultado.getString("nome"));
                polos.add(p);
            }
            Conexao.close(conexao, query, resultado);
            return polos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Polo> getPolosCompleto() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM polo ORDER BY nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            ArrayList<Polo> polos = new ArrayList<Polo>();
            while (resultado.next()) {
                Polo p = new Polo(resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getString("descricao"),
                        resultado.getString("telefone"),
                        resultado.getString("endereco"),
                        resultado.getString("pos_graduacao"),
                        resultado.getString("extensao"),
                        resultado.getString("graduacao"),
                        resultado.getString("coordenador"),
                        resultado.getString("telefone_coordenador"),
                        resultado.getString("email_coordenador"));
                polos.add(p);
            }
            Conexao.close(conexao, query, resultado);
            return polos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<CidadeSede> getCidadesSede() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM cidade_sede ORDER BY nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            ArrayList<CidadeSede> cidadesSede = new ArrayList<CidadeSede>();
            while (resultado.next()) {
                CidadeSede sede = new CidadeSede(resultado.getInt("numero"), resultado.getString("nome"));
                cidadesSede.add(sede);
            }
            Conexao.close(conexao, query, resultado);
            return cidadesSede;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Inscricao getInscricao(String numeroInscricao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM usuario_curso WHERE inscricao = ? ";
            String sql2 = "SELECT homologado FROM inscricao WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, numeroInscricao);
            ResultSet resultado = query.executeQuery();
            Inscricao inscricao = null;
            int homologado = 0;
            PreparedStatement query2 = conexao.prepareStatement(sql2);
            query2.setInt(1, Integer.parseInt(numeroInscricao));
            ResultSet resultado2 = query2.executeQuery();
            if (resultado2.next()) {
                homologado = resultado2.getInt("homologado");
            }
            if (resultado.next()) {
                inscricao = new Inscricao(resultado.getInt("numero_curso"),
                        resultado.getString("nome_curso"),
                        resultado.getString("nome"),
                        resultado.getString("sobrenome"),
                        resultado.getString("cpf"),
                        resultado.getString("modalidade"),
                        resultado.getInt("inscricao"),
                        homologado);
            }
            Conexao.close(conexao, query, resultado);
            return inscricao;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Usuario getUsuario(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Usuario usuario = null;
            Endereco e;
            String sql = getSqlUsuario();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet resultado = query.executeQuery();

            if (resultado.next()) {
                e = new Endereco(
                        resultado.getString("u.endereco_cep"),
                        resultado.getString("u.endereco_logradouro"),
                        resultado.getString("u.endereco_numero"),
                        resultado.getString("u.endereco_bairro"),
                        resultado.getString("cidade.nome"),
                        resultado.getString("u.endereco_estado"),
                        resultado.getInt("u.estado"),
                        resultado.getInt("u.cidade"));
                if (resultado.getObject("fun.funcoes_id") != null) {
                    switch (resultado.getInt("fun.funcoes_id")) {
                        case 1: {
                            usuario = new CoordenadorDeCurso(
                                    resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                        case 2: {
                            usuario = new CoordenadorPedagogico(
                                    resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                        case 3: {
                            usuario = new Administrador(
                                    resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                        case 6: {
                            String sql2 = "SELECT * FROM coordenador_tem_polo WHERE coordenador_cpf = ? ";
                            PreparedStatement query2 = conexao.prepareStatement(sql2);
                            query2.setString(1, cpf);
                            ResultSet rp = query2.executeQuery();
                            if (rp.next()) {
                                int polo = rp.getInt("polo_numero");
                                usuario = new CoordenadorDePolo(
                                        resultado.getString("u.cpf"),
                                        resultado.getString("u.nome"),
                                        resultado.getString("u.sobrenome"),
                                        new Date(resultado.getDate("u.nascimento").getTime()),
                                        resultado.getString("u.sexo").charAt(0),
                                        resultado.getBoolean("u.ensino_medio"),
                                        resultado.getBoolean("u.graduacao"),
                                        resultado.getBoolean("u.especializacao"),
                                        resultado.getBoolean("u.mestrado"),
                                        resultado.getBoolean("u.doutorado"),
                                        resultado.getString("u.email"),
                                        resultado.getString("u.ddd_telefone"),
                                        resultado.getString("u.telefone"),
                                        resultado.getString("u.senha"),
                                        e,
                                        polo);
                            }
                            rp.close();
                            query2.close();
                            break;
                        }
                        case 7: {
                            String sql2 = "SELECT gti.ipes AS id, si.ipes AS ipes FROM gestor_tem_ipes gti INNER JOIN siead_ipes si ON si.id_ipes = gti.ipes WHERE usuario = ? ";
                            PreparedStatement query2 = conexao.prepareStatement(sql2);
                            query2.setString(1, cpf);
                            ResultSet ri = query2.executeQuery();
                            if (ri.next()) {
                                usuario = new GestorIPES(ri.getInt("id"),
                                        ri.getString("ipes"),
                                        resultado.getString("u.cpf"),
                                        resultado.getString("u.nome"),
                                        resultado.getString("u.sobrenome"),
                                        new Date(resultado.getDate("u.nascimento").getTime()),
                                        resultado.getString("u.sexo").charAt(0),
                                        resultado.getBoolean("u.ensino_medio"),
                                        resultado.getBoolean("u.graduacao"),
                                        resultado.getBoolean("u.especializacao"),
                                        resultado.getBoolean("u.mestrado"),
                                        resultado.getBoolean("u.doutorado"),
                                        resultado.getString("u.email"),
                                        resultado.getString("u.ddd_telefone"),
                                        resultado.getString("u.telefone"),
                                        resultado.getString("u.senha"),
                                        e);
                            }
                            ri.close();
                            query2.close();
                            break;
                        }
                        case 8: {
                            usuario = new UsuarioCIAR(
                                    resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                        case 9: {
                            usuario = new UsuarioSeduc(resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                        case 10: {
                            usuario = new CoordenadorUAB(resultado.getString("u.cpf"),
                                    resultado.getString("u.nome"),
                                    resultado.getString("u.sobrenome"),
                                    new Date(resultado.getDate("u.nascimento").getTime()),
                                    resultado.getString("u.sexo").charAt(0),
                                    resultado.getBoolean("u.ensino_medio"),
                                    resultado.getBoolean("u.graduacao"),
                                    resultado.getBoolean("u.especializacao"),
                                    resultado.getBoolean("u.mestrado"),
                                    resultado.getBoolean("u.doutorado"),
                                    resultado.getString("u.email"),
                                    resultado.getString("u.ddd_telefone"),
                                    resultado.getString("u.telefone"),
                                    resultado.getString("u.senha"),
                                    e);
                            break;
                        }
                    }
                } else {
                    usuario = new Usuario(
                            resultado.getString("u.cpf"),
                            resultado.getString("u.nome"),
                            resultado.getString("u.sobrenome"),
                            new Date(resultado.getDate("u.nascimento").getTime()),
                            resultado.getString("u.sexo").charAt(0),
                            resultado.getBoolean("u.ensino_medio"),
                            resultado.getBoolean("u.graduacao"),
                            resultado.getBoolean("u.especializacao"),
                            resultado.getBoolean("u.mestrado"),
                            resultado.getBoolean("u.doutorado"),
                            resultado.getString("u.email"),
                            resultado.getString("u.ddd_telefone"),
                            resultado.getString("u.telefone"),
                            resultado.getString("u.senha"),
                            e);
                }
            }
            Conexao.close(conexao, query, resultado);
            return usuario;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<String[]> getAprovados(Curso curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM aprovado WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso.getNumero());
            ResultSet resultlado = query.executeQuery();
            ArrayList<String[]> aprovados = new ArrayList<String[]>();
            while (resultlado.next()) {
                aprovados.add(
                        new String[]{
                            resultlado.getString("inscricao"),
                            resultlado.getString("nome"),
                            resultlado.getString("sobrenome"),
                            resultlado.getString("email"),
                            resultlado.getString("ddd_telefone"),
                            resultlado.getString("telefone")
                        });
            }
            Conexao.close(conexao, query, resultlado);
            return aprovados;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getInscritos(int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario = null;
            Inscrito inscrito = null;
            String sql = getSQLInscritos();
            PreparedStatement query = conexao.prepareCall(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                usuario = getUsuario(result.getString("cpf"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("tutor_orientador"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        result.getInt("numero_curso"),
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));
                Polo p = new Polo(result.getInt("polo_numero"), result.getString("polo_nome"));
                inscrito.setPolo(p);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }

    }

    //Destinado aos cursos com modalidade Orientador
    public ArrayList<Inscrito> getInscritosCursoOrientador(int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario = null;
            Inscrito inscrito = null;
            String sql = getSQLInscritosCursoOrientador();
            PreparedStatement query = conexao.prepareCall(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                usuario = getUsuario(result.getString("cpf"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("tutor_orientador"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        result.getInt("numero_curso"),
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));
                CidadeSede cidadeSede = new CidadeSede(result.getInt("cidade_sede_numero"), result.getString("cidade_sede_nome"));
                inscrito.setCidadeSede(cidadeSede);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }

    }

    //INSCRITOS
    public ArrayList<Inscrito> getInscritosPorPolo(int numeroCurso) throws SQLException {
        return getInscritosPorPolo(numeroCurso, null);
    }

    public ArrayList<Inscrito> getHomologados(int numeroCurso) throws SQLException {
        return getHomologados(numeroCurso, null);
    }

    public ArrayList<Inscrito> getInscricoesAprovadas(int numeroCurso) throws SQLException {
        return getInscricoesAprovadas(numeroCurso, null);
    }

    public ArrayList<Inscrito> getInscritosPorPolo(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy;
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, polo, nomeusuario";
            }
            String sql = getSQLInscritosPorPolo(orderBy);
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();

            while (result.next()) {
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));
                Polo p = new Polo(result.getInt("polo_numero"), result.getString("polo"));
                inscrito.setPolo(p);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getInscritosPorCidadeSede(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy;
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, cidade_sede, nomeusuario";
            }
            String sql = getSQLInscritosPorCidadeSede(orderBy);
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();

            while (result.next()) {
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));

                CidadeSede cidade = new CidadeSede(result.getInt("cidade_sede_numero"), result.getString("cidade_sede"));
                inscrito.setCidadeSede(cidade);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getHomologadosPorCidadeSede(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy;
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, cidade_sede, nomeusuario";
            }
            String sql = getSQLHomologadosPorCidadeSede(orderBy);

            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));

                CidadeSede cidade = new CidadeSede(result.getInt("cidade_sede_numero"), result.getString("cidade_sede"));
                inscrito.setCidadeSede(cidade);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getHomologados(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy;
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, polo, nomeusuario";
            }
            String sql = getSQLHomologados(orderBy);

            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));

                Polo p = new Polo(result.getInt("polo_numero"), result.getString("polo"));
                inscrito.setPolo(p);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getInscricoesAprovadas(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy = "";
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, polo, nomeusuario";
            }
            String sql = getSQLAprovados(orderBy);

            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                //usuario = getUsuario(result.getString("cpf"));
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));

                Polo p = new Polo(result.getInt("polo_numero"), result.getString("polo"));
                inscrito.setPolo(p);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Inscrito> getInscricoesAprovadasPorCidadeSede(int numeroCurso, String[] ordem) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Inscrito> inscritos = new ArrayList<Inscrito>();
            Usuario usuario;
            Inscrito inscrito;
            String orderBy = "";
            if (ordem != null && ordem.length > 0) {
                orderBy = vetorToString(ordem);
            } else {
                orderBy = " ORDER BY funcao, cidade_sede, nomeusuario";
            }
            String sql = getSQLAprovadosPorCidadeSede(orderBy);

            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                //usuario = getUsuario(result.getString("cpf"));
                usuario = new Usuario(result.getString("usuario_cpf"),
                        result.getString("nomeusuario"),
                        result.getString("usuario_sobrenome"),
                        result.getString("usuario_email"));
                inscrito = new Inscrito(usuario,
                        result.getInt("homologado"),
                        result.getInt("numero"),
                        result.getBoolean("aprovacao"),
                        result.getString("curriculo"),
                        result.getString("questao"),
                        result.getString("funcao"),
                        result.getString("presenca_encontro_presencial"),
                        new Date(result.getDate("hora").getTime()),
                        numeroCurso,
                        result.getString("link_lattes"),
                        result.getBoolean("recurso"),
                        result.getString("recurso_texto"),
                        result.getBoolean("recurso_indeferido"));

                CidadeSede cidade = new CidadeSede(result.getInt("cidade_sede_numero"), result.getString("cidade_sede"));
                inscrito.setCidadeSede(cidade);
                inscrito.setCidade(result.getString("cidade"));
                inscritos.add(inscrito);
            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //END-INSCRITOS

    public ArrayList<Curso> getInscricoesAbertas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT *  FROM curso WHERE inicio_inscricao <= DATE(now()) AND (fim_inscricao) >= DATE(now())";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        new Date(resultado.getDate("inicio_inscricao").getTime()),
                        new Date(resultado.getDate("fim_inscricao").getTime()),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getInscricoesAbertasCursistas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT *  FROM curso WHERE tipo = 2 AND inicio_inscricao <= DATE(now()) AND (fim_inscricao) >= DATE(now())";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        new Date(resultado.getDate("inicio_inscricao").getTime()),
                        new Date(resultado.getDate("fim_inscricao").getTime()),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getInscricoesAbertasTutores() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT *  FROM curso WHERE tipo <> 2 AND inicio_inscricao <= DATE(now()) AND (fim_inscricao) >= DATE(now())";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        new Date(resultado.getDate("inicio_inscricao").getTime()),
                        new Date(resultado.getDate("fim_inscricao").getTime()),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getInscricoesEncerradas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEmAndamento() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 1 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEmAndamentoCursistas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 1 AND tipo = 2 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEmAndamentoTutores() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 1 AND tipo <> 2 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEncerrado() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 0 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEncerradoCursistas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 0  AND tipo = 2 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getcursoProcessoEncerradoTutores() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = null;
            String sql = "SELECT * FROM curso WHERE fim_inscricao < DATE(now()) AND andamento = 0  AND tipo <> 2 ORDER BY fim_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                if (cursos == null) {
                    cursos = new ArrayList<Curso>();
                }
                cursos.add(new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void encerrarProcessoSeletivo(int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE curso SET andamento=? WHERE numero=?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setBoolean(1, false);
            query.setInt(2, curso);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Curso getInscricaoAberta(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Curso curso = null;
            String sql = "SELECT * FROM curso WHERE inicio_inscricao <= DATE(now()) AND fim_inscricao >= DATE(now()) AND numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numero);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                curso = new Curso(
                        resultado.getString("nome"),
                        resultado.getString("questao"),
                        resultado.getInt("numero"),
                        resultado.getInt("carga_horaria"),
                        new Date(resultado.getDate("inicio_inscricao").getTime()),
                        new Date(resultado.getDate("fim_inscricao").getTime()),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim"));
            }
            Conexao.close(conexao, query, resultado);
            return curso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Usuario> getMatriculados(int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT usuario_cpf FROM inscricao "
                    + " WHERE aprovacao = 1 AND presenca_encontro_presencial = ? AND numero_curso = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, String.valueOf('p'));
            query.setInt(2, curso);
            ResultSet resultado = query.executeQuery();
            ArrayList<Usuario> usuarios = new ArrayList<Usuario>();
            while (resultado.next()) {
                usuarios.add(getUsuario(resultado.getString("usuario_cpf")));
            }
            Conexao.close(conexao, query, resultado);
            return usuarios;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Integer> getInscricoesAprovados(int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "select * from aprovado WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso);
            ResultSet resultado = query.executeQuery();
            ArrayList<Integer> aprovados = new ArrayList<Integer>();
            while (resultado.next()) {
                aprovados.add(new Integer(resultado.getString("inscricao")));
            }
            Conexao.close(conexao, query, resultado);
            return aprovados;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void confirmarPresenca(String inscricao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET presenca_encontro_presencial = ? WHERE numero = ? LIMIT 1 ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, String.valueOf('p'));
            query.setInt(2, Integer.parseInt(inscricao));
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } catch (NumberFormatException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void confirmarFalta(String inscricao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET presenca_encontro_presencial = ? WHERE numero = ? LIMIT 1 ;";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, String.valueOf('f'));
            query.setInt(2, Integer.parseInt(inscricao));
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } catch (NumberFormatException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Inscrito getInscricao(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLgetInscricaoPorNumero();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numero);
            ResultSet resultado = query.executeQuery();
            Inscrito inscrito = null;
            if (resultado.next()) {
                String modalidade = resultado.getString("tutor_orientador");
                Polo p = new Polo(resultado.getInt("numero"), resultado.getString("nome"));
                boolean aprovacao = resultado.getBoolean("aprovacao");
                String curriculo = resultado.getString("curriculo");
                String questao = resultado.getString("questao");
                int homologado = resultado.getInt("homologado");
                Usuario u = getUsuario(resultado.getString("cpf"));
                int numCurso = resultado.getInt("numero_curso");
                String lattes = resultado.getString("link_lattes");
                boolean recurso = resultado.getBoolean("recurso");
                String textoRecurso = resultado.getString("recurso_texto");
                boolean indeferimentoRecurso = resultado.getBoolean("recurso_indeferido");
                inscrito = new Inscrito(u, homologado, numero, aprovacao, curriculo, questao, modalidade, numCurso, lattes, recurso, textoRecurso, indeferimentoRecurso);
                inscrito.setPolo(p);
            }
            Conexao.close(conexao, query, resultado);
            return inscrito;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Inscrito getInscricaoOrientador(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLgetInscricaoPorNumeroOrientador();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numero);
            ResultSet resultado = query.executeQuery();
            Inscrito inscrito = null;
            if (resultado.next()) {
                String modalidade = resultado.getString("tutor_orientador");
                CidadeSede cidade = new CidadeSede(resultado.getInt("numero"), resultado.getString("nome"));
                boolean aprovacao = resultado.getBoolean("aprovacao");
                String curriculo = resultado.getString("curriculo");
                String questao = resultado.getString("questao");
                int homologado = resultado.getInt("homologado");
                Usuario u = getUsuario(resultado.getString("cpf"));
                int numCurso = resultado.getInt("numero_curso");
                String lattes = resultado.getString("link_lattes");
                boolean recurso = resultado.getBoolean("recurso");
                String textoRecurso = resultado.getString("recurso_texto");
                boolean indeferimentoRecurso = resultado.getBoolean("recurso_indeferido");
                inscrito = new Inscrito(u, homologado, numero, aprovacao, curriculo, questao, modalidade, numCurso, lattes, recurso, textoRecurso, indeferimentoRecurso);
                inscrito.setCidadeSede(cidade);
            }
            Conexao.close(conexao, query, resultado);
            return inscrito;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Polo> getPolos(Curso c) throws SQLException {
        Connection conexao = Conexao.getConexao();
        ArrayList<Polo> polos = new ArrayList<Polo>();
        try {
            String sql = getSQLPolosPorCurso();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, c.getNumero());
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                polos.add(new Polo(resultado.getInt("numero"), resultado.getString("nome")));
            }
            Conexao.close(conexao, query, resultado);
            return polos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Polo getPolo(int p) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Polo polo = null;
            String sql = "SELECT * FROM polo WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, p);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                polo = new Polo(resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getString("descricao"),
                        resultado.getString("telefone"),
                        resultado.getString("endereco"),
                        resultado.getString("pos_graduacao"),
                        resultado.getString("extensao"),
                        resultado.getString("graduacao"),
                        resultado.getString("coordenador"),
                        resultado.getString("telefone_coordenador"),
                        resultado.getString("email_coordenador"));
            }
            Conexao.close(conexao, query, resultado);
            return polo;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public CidadeSede getCidadesSede(Curso c) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            CidadeSede cidadeSede = null;
            String sql = getSQLCidadesSedePorCurso();
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, c.getNumero());
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cidadeSede = new CidadeSede(resultado.getInt("numero"),
                        resultado.getString("nome"));
            }
            Conexao.close(conexao, query, resultado);
            return cidadeSede;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public CidadeSede getCidadeSede(int cs) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            CidadeSede cidadeSede = null;
            String sql = "SELECT * FROM cidade_sede WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, cs);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cidadeSede = new CidadeSede(resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getString("uf"),
                        resultado.getString("endereco"));
            }
            Conexao.close(conexao, query, resultado);
            return cidadeSede;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<ModeloCertificado> getModelosCertificados() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<ModeloCertificado> modelos = new ArrayList<ModeloCertificado>();
            String sql = "SELECT id, nome, conteudo FROM modelo_certificado";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                modelos.add(new ModeloCertificado(
                        resultado.getInt("id"),
                        resultado.getString("nome"),
                        resultado.getString("conteudo")));
            }
            Conexao.close(conexao, query, resultado);
            return modelos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    //Método de inserção destinado somente quando a finalidade é orientador
    public void inserirInscricaoOrientador(Usuario u, int numeroCurso, String curriculo, String questao,
            int numeroCidadeSede, String tutorOrientador, String escolaridade, String linkLattes) throws SQLException, MessagingException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirInscricaoOrientador();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setBoolean(indice++, false);
            query.setString(indice++, String.valueOf('i'));
            query.setInt(indice++, numeroCurso);
            query.setInt(indice++, numeroCidadeSede);
            query.setString(indice++, tutorOrientador);
            query.setString(indice++, curriculo);
            query.setString(indice++, questao);
            query.setString(indice++, u.getCpf());
            query.setString(indice++, escolaridade);
            query.setString(indice++, linkLattes);
            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            Conexao.close(conexao, query);

            Comunicacao c = new Comunicacao();
            Curso curso = getCurso(numeroCurso);
            String mensagem = "Olá, " + u.getNome() + ". Sua inscrição no Curso " + curso.getNome() + ", oferecido pela Universidade Federal de Goiás, foi confirmada. "
                    + " Essa mensagem é gerada automaticamente, por favor não responder.";
            String assunto = "Confirmação de inscrição CIAR - UFG";
            c.enviarEmail(new String[]{u.getEmail()}, assunto, mensagem, "noreply@ciar.ufg.br");
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } catch (MessagingException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirInscricao(Usuario u, int numeroCurso, String curriculo, String questao,
            int numeroPolo, String tutorOrientador, String escolaridade, String linkLattes) throws SQLException, MessagingException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirInscricao();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setBoolean(indice++, false);
            query.setString(indice++, String.valueOf('i'));
            query.setInt(indice++, numeroCurso);
            query.setInt(indice++, numeroPolo);
            query.setString(indice++, tutorOrientador);
            query.setString(indice++, curriculo);
            query.setString(indice++, questao);
            query.setString(indice++, u.getCpf());
            query.setString(indice++, escolaridade);
            query.setString(indice++, linkLattes);
            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int numeroInscricao = result.getInt(1);
            Conexao.close(conexao, query);

            Comunicacao c = new Comunicacao();
            //String randomPass = Inscricao.getRandomPass(6);
            Curso curso = getCurso(numeroCurso);
            String mensagem = "Olá, " + u.getNome() + ". Sua inscrição no Curso " + curso.getNome() + ", oferecido pela Universidade Federal de Goiás, foi confirmada. "
                    + " Essa mensagem é gerada automaticamente, por favor não responder."/* A sua senha no moodle será: " + randomPass + "."*/;
            String assunto = "Confirmação de inscrição CIAR - UFG";
            c.enviarEmail(new String[]{u.getEmail()}, assunto, mensagem, "noreply@ciar.ufg.br");
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } catch (MessagingException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    //Método de inserção destinado somente quando a finalidade é Aluno (cursista)
    public void inserirInscricao(Usuario u, int numeroCurso, int numeroPolo,
            String curriculo, String questao, String linkLattes) throws SQLException, MessagingException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirInscricaoAluno();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setBoolean(indice++, false);
            query.setString(indice++, String.valueOf('i'));
            query.setInt(indice++, numeroCurso);
            query.setInt(indice++, numeroPolo);
            query.setString(indice++, curriculo);
            query.setString(indice++, questao);
            query.setString(indice++, u.getCpf());
            query.setString(indice++, linkLattes);
            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int numeroInscricao = result.getInt(1);
            Conexao.close(conexao, query);

            Comunicacao c = new Comunicacao();
            //String randomPass = Inscricao.getRandomPass(6);
            Curso curso = getCurso(numeroCurso);
            String mensagem = "Olá, " + u.getNome() + ". Sua inscrição no Curso " + curso.getNome() + ", oferecido pela Universidade Federal de Goiás, foi confirmada."
                    + " Essa mensagem é gerada automaticamente, por favor não responder."/* A sua senha no moodle será: " + randomPass + "."*/;
            String assunto = "Confirmação de inscrição CIAR - UFG";
            c.enviarEmail(new String[]{u.getEmail()}, assunto, mensagem, "noreply@ciar.ufg.br");
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } catch (MessagingException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isAlunoInscrito(Usuario usuario, int numero_curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT numero FROM inscricao WHERE numero_curso = ? AND usuario_cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numero_curso);
            query.setString(2, usuario.getCpf());
            ResultSet rs = query.executeQuery();
            if (rs.next()) {
                Conexao.close(conexao, query, rs);
                return true;
            }
            Conexao.close(conexao, query, rs);
            return false;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isCertificadoDoCIAR(int numeroInscricao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT modelo_certificado FROM inscricao, curso WHERE curso.numero = inscricao.numero_curso AND inscricao.numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroInscricao);
            ResultSet rs = query.executeQuery();
            if (rs.next()) {
                if (rs.getInt("modelo_certificado") != 0) {
                    Conexao.close(conexao, query, rs);
                    return true;
                }
            }
            Conexao.close(conexao, query, rs);
            return false;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isAlunoAprovado(String cpf, int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT numero FROM inscricao, aprovacao WHERE usuario_cpf = ? AND numero_curso = ? AND aprovacao = 1 AND numero = inscricao";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            query.setInt(2, numeroCurso);
            ResultSet rs = query.executeQuery();
            if (rs.next()) {
                Conexao.close(conexao, query, rs);
                return true;
            }
            Conexao.close(conexao, query, rs);
            return false;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Curso inserirCurso(Curso curso, int[] polos) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirCurso();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setString(indice++, curso.getNome());
            query.setInt(indice++, curso.getCargaHoraria());
            query.setDate(indice++, new java.sql.Date(curso.getInicioInscricao().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimInscricao().getTime()));
            query.setString(indice++, curso.getQuestao());
            query.setInt(indice++, curso.getTipo());
            query.setInt(indice++, curso.getModeloCertificado());
            query.setString(indice++, curso.getTipoVaga());
            query.setInt(indice++, curso.getMinCaracteresQuestao());
            query.setInt(indice++, curso.getMaxCaracteresQuestao());
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoPreliminar().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoFinal().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getInicioRecurso().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimRecurso().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            curso.setNumero(result_id);
            String sql2 = "INSERT INTO curso_em_polo (numero_curso, numero_polo) VALUES (? , ? )";
            for (int p : polos) {
                PreparedStatement query2 = conexao.prepareStatement(sql2);
                query2.setInt(1, curso.getNumero());
                query2.setInt(2, p);
                query2.executeUpdate();
                query2.close();
            }
            Conexao.close(conexao, query, result);
            return curso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Curso inserirCursoCidadesSede(Curso curso, int[] cidadesSede) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirCurso();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setString(indice++, curso.getNome());
            query.setInt(indice++, curso.getCargaHoraria());
            query.setDate(indice++, new java.sql.Date(curso.getInicioInscricao().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimInscricao().getTime()));
            query.setString(indice++, curso.getQuestao());
            query.setInt(indice++, curso.getTipo());
            query.setInt(indice++, curso.getModeloCertificado());
            query.setString(indice++, curso.getTipoVaga());
            query.setInt(indice++, curso.getMinCaracteresQuestao());
            query.setInt(indice++, curso.getMaxCaracteresQuestao());
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoPreliminar().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoFinal().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getInicioRecurso().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimRecurso().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            curso.setNumero(result_id);
            String sql2 = "INSERT INTO curso_em_cidade_sede (numero_curso, numero_cidade) VALUES (? , ? )";
            for (int c : cidadesSede) {
                PreparedStatement query2 = conexao.prepareStatement(sql2);
                query2.setInt(1, curso.getNumero());
                query2.setInt(2, c);
                query2.executeUpdate();
                query2.close();
            }
            Conexao.close(conexao, query, result);
            return curso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Curso inserirCursoCidadesSedeEPolo(Curso curso, int[] cidadesSede, int[] polos) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = getSQLInserirCurso();
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            int indice = 1;
            query.setString(indice++, curso.getNome());
            query.setInt(indice++, curso.getCargaHoraria());
            query.setDate(indice++, new java.sql.Date(curso.getInicioInscricao().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimInscricao().getTime()));
            query.setString(indice++, curso.getQuestao());
            query.setInt(indice++, curso.getTipo());
            query.setInt(indice++, curso.getModeloCertificado());
            query.setString(indice++, curso.getTipoVaga());
            query.setInt(indice++, curso.getMinCaracteresQuestao());
            query.setInt(indice++, curso.getMaxCaracteresQuestao());
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoPreliminar().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getHomologacaoFinal().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getInicioRecurso().getTime()));
            query.setDate(indice++, new java.sql.Date(curso.getFimRecurso().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            curso.setNumero(result_id);
            String sql2 = "INSERT INTO curso_em_cidade_sede (numero_curso, numero_cidade) VALUES (? , ? )";
            for (int c : cidadesSede) {
                PreparedStatement query2 = conexao.prepareStatement(sql2);
                query2.setInt(1, curso.getNumero());
                query2.setInt(2, c);
                query2.executeUpdate();
                query2.close();
            }
            String sql3 = "INSERT INTO curso_em_polo (numero_curso, numero_polo) VALUES (? , ? )";
            for (int p : polos) {
                PreparedStatement query3 = conexao.prepareStatement(sql3);
                query3.setInt(1, curso.getNumero());
                query3.setInt(2, p);
                query3.executeUpdate();
                query3.close();
            }
            Conexao.close(conexao, query, result);
            return curso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirCursoExterno(CursoExterno curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO curso_externo (nome, link, tipo, inicio_inscricao, fim_inscricao) VALUES (?, ?, ?, ?, ?)";
            PreparedStatement statement = conexao.prepareStatement(sql);
            statement.setString(1, curso.getNome());
            statement.setString(2, curso.getLink());
            statement.setInt(3, curso.getTipo());
            statement.setDate(4, new java.sql.Date(curso.getInicioInscricao().getTime()));
            statement.setDate(5, new java.sql.Date(curso.getFimInscricao().getTime()));
            statement.executeUpdate();
            statement.close();
            Conexao.close(conexao);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

//    public void atualizarCurso(int cursoEADmin, long cursoMoodle) throws SQLException {
//        stmt.executeUpdate("UPDATE curso` SET `curso_moodle` = '" + cursoMoodle + "' WHERE `curso`.`numero` =" + cursoEADmin + " LIMIT 1 ;");
//    }
    public ArrayList<Curso> getCurso(CoordenadorDeCurso coordenador) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = new ArrayList<Curso>();
            String sql = "SELECT * FROM coordenador_curso, curso WHERE curso.numero = coordenador_curso.numero AND cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, coordenador.getCpf());
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cursos.add(new Curso(
                        resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getString("questao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getString("tipo_vaga"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<CursoExterno> getCursosExternos(int tipo) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<CursoExterno> cursos = new ArrayList<CursoExterno>();
            String sql = "";
            if (tipo == 1) //Para Cursistas
            {
                sql = "SELECT * FROM curso_externo WHERE tipo = 1 AND inicio_inscricao <= DATE(now()) AND (fim_inscricao) >= DATE(now())";
            } else if (tipo == 2) //Para Tutores
            {
                sql = "SELECT * FROM curso_externo WHERE tipo = 2 AND inicio_inscricao <= DATE(now()) AND (fim_inscricao) >= DATE(now())";
            }

            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cursos.add(new CursoExterno(
                        resultado.getString("nome"),
                        resultado.getString("link"),
                        resultado.getInt("tipo"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Curso getCurso(int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Curso curso = null;
            String sql = "SELECT * FROM curso WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroCurso);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                curso = new Curso(resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getString("questao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getString("tipo_vaga"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim"));
            }
            Conexao.close(conexao, query, resultado);
            return curso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public int getNumeroCurso(Curso curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT numero FROM curso WHERE nome = ? AND tipo = ? AND inicio_inscricao = ? AND fim_inscricao = ? AND homologacao_preliminar = ? AND homologacao_final = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            //Conversão para java SQL Date
            java.util.Date dataInicio = curso.getInicioInscricao();
            java.sql.Date dataSqlinicio = new java.sql.Date(dataInicio.getTime());

            java.util.Date dataFim = curso.getFimInscricao();
            java.sql.Date dataSqlFim = new java.sql.Date(dataFim.getTime());

            java.util.Date dataHomPre = curso.getHomologacaoPreliminar();
            java.sql.Date dataSqlHomPre = new java.sql.Date(dataHomPre.getTime());

            java.util.Date dataHomFinal = curso.getHomologacaoFinal();
            java.sql.Date dataSqlHomFinal = new java.sql.Date(dataHomFinal.getTime());

            query.setString(1, curso.getNome());
            query.setInt(2, curso.getTipo());
            query.setDate(3, dataSqlinicio);
            query.setDate(4, dataSqlFim);
            query.setDate(5, dataSqlHomPre);
            query.setDate(6, dataSqlHomFinal);

            ResultSet resultado = query.executeQuery();
            int retorno = 0;
            if (resultado.next()) {
                retorno = resultado.getInt("numero");
            }
            Conexao.close(conexao, query, resultado);
            return retorno;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getCurso() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = new ArrayList<Curso>();
            String sql = "SELECT * FROM curso";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cursos.add(new Curso(
                        resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getString("questao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getString("tipo_vaga"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getCursoCursistas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = new ArrayList<Curso>();
            String sql = "SELECT * FROM curso where tipo = 2 order by inicio_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cursos.add(new Curso(
                        resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getString("questao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getString("tipo_vaga"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Curso> getCursoTutores() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Curso> cursos = new ArrayList<Curso>();
            String sql = "SELECT * FROM curso where tipo <> 2 order by inicio_inscricao DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                cursos.add(new Curso(
                        resultado.getInt("numero"),
                        resultado.getString("nome"),
                        resultado.getInt("carga_horaria"),
                        resultado.getDate("inicio_inscricao"),
                        resultado.getDate("fim_inscricao"),
                        resultado.getString("questao"),
                        resultado.getInt("tipo"),
                        resultado.getInt("modelo_certificado"),
                        resultado.getString("tipo_vaga"),
                        resultado.getInt("min_caracteres_questao"),
                        resultado.getInt("max_caracteres_questao"),
                        resultado.getDate("homologacao_preliminar"),
                        resultado.getDate("homologacao_final"),
                        resultado.getDate("recurso_inicio"),
                        resultado.getDate("recurso_fim")));
            }
            Conexao.close(conexao, query, resultado);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void aprovarInscricao(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET aprovacao = ? WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setBoolean(1, true);
            query.setInt(2, numero);
            query.executeUpdate();
            Conexao.close(conexao, query);
            //cadastrarNoMoodle(numero);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void desaprovarInscricao(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET aprovacao = ? WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setBoolean(1, false);
            query.setInt(2, numero);
            query.executeUpdate();
            Conexao.close(conexao, query);
            //cadastrarNoMoodle(numero);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

//    private MoodleUser cadastrarNoMoodle(int inscricao) throws Exception {
//        Query q = new Query();
//        Inscrito insc = q.getInscricao(inscricao);
//        Usuario usuarioEADmin = (new Query()).getUsuario(insc.getCpf());
//        MoodleRestWebService.init(testMoodle, wstoken);
//        MoodleUser usuarioAdapter = new MoodleUser(usuarioEADmin.getCpf(), usuarioEADmin.getSenha(), usuarioEADmin.getNome(), usuarioEADmin.getSobrenome(), usuarioEADmin.getEmail());
//        usuarioAdapter.setCity(usuarioEADmin.getEndereco().getCidade());
//        usuarioAdapter.setCountry("BR");
//        usuarioAdapter.setIdNumber("" + inscricao);
//        usuarioAdapter.setDescription(insc.getCurriculo());
//        MoodleUser usuarioMoodle = MoodleRestUser.createUser(usuarioAdapter);
//        return usuarioMoodle;
//    }
    public void homologarInscricao(int numero) throws SQLException, MessagingException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET homologado = ? WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setBoolean(1, true);
            query.setInt(2, numero);
            query.executeUpdate();
            Conexao.close(conexao, query);

            Comunicacao c = new Comunicacao();
            Inscricao i = getInscricao(String.valueOf(numero));
            Curso curso = getCurso(i.getNumeroCurso());
            Usuario u = getUsuario(i.getCpf());
            String mensagem = "Olá, " + u.getNome() + ". A situação da sua inscrição no Processo Seletivo " + curso.getNome() + ", oferecido pela Universidade Federal de Goiás, foi alterada para \"Inscrição Homologada\". Consulte mais informações no site do EADmin. "
                    + " Essa mensagem é gerada automaticamente, por favor não responder.";
            String assunto = "Alteração na Situação da Inscrição CIAR - UFG";
            c.enviarEmail(new String[]{u.getEmail()}, assunto, mensagem, "noreply@ciar.ufg.br");
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void naoHomologarInscricao(int numero) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET homologado = ? WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, 2);
            query.setInt(2, numero);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void desomologarInscricao(int numero) throws SQLException, MessagingException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET homologado = ? WHERE numero = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setBoolean(1, false);
            query.setInt(2, numero);
            query.executeUpdate();
            Conexao.close(conexao, query);

            Comunicacao c = new Comunicacao();
            Inscricao i = getInscricao(String.valueOf(numero));
            Curso curso = getCurso(i.getNumeroCurso());
            Usuario u = getUsuario(i.getCpf());
            String mensagem = "Olá, " + u.getNome() + ". A situação da sua inscrição no Curso: " + curso.getNome() + ", oferecido pela Universidade Federal de Goiás, foi alterada para \"Não Homologada\". Consulte mais informações no site do EADmin."
                    + " Essa mensagem é gerada automaticamente, por favor não responder.";
            String assunto = "Alteração na Situação da Inscrição CIAR - UFG";
            c.enviarEmail(new String[]{u.getEmail()}, assunto, mensagem, "noreply@ciar.ufg.br");
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void iniciarRecurso(int inscricao, String textoRecurso, String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET recurso = ?, recurso_texto = ? WHERE numero = ? AND usuario_cpf = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, 1);
            query.setString(2, textoRecurso);
            query.setInt(3, inscricao);
            query.setString(4, cpf);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void indeferirRecurso(int inscricao, String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE inscricao SET recurso_indeferido = ? WHERE numero = ? AND usuario_cpf = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, 1);
            query.setInt(2, inscricao);
            query.setString(3, cpf);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void aprovarNoCurso(String usuario, int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT numero FROM inscricao WHERE numero_curso = ? AND usuario_cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso);
            query.setString(2, usuario);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                PreparedStatement query2 = conexao.prepareStatement("INSERT INTO aprovacao (inscricao) VALUES ( ? )");
                query2.setInt(1, resultado.getInt("numero"));
                query2.executeUpdate();
                query2.close();
            }
            Conexao.close(conexao, query, resultado);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Certificado getCertificado(int numeroInscricao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Certificado certificado = null;
            String sql = "SELECT *  FROM certificado WHERE inscricao = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, numeroInscricao);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                certificado = new Certificado(
                        resultado.getInt("inscricao"),
                        resultado.getString("nome_curso"),
                        resultado.getInt("carga"),
                        resultado.getString("nome"),
                        resultado.getInt("numero_curso"),
                        resultado.getString("conteudo_certificado"));
            }
            Conexao.close(conexao, query, resultado);
            return certificado;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isCertificado(int numeroInscricao) throws SQLException {
        if (getCertificado(numeroInscricao) != null) {
            return true;
        } else {
            return false;
        }
    }

    public void inserirDocumento(String legenda, String url, int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO documento_curso (curso, url, legenda) VALUES ( ? , ? , ? )";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso);
            query.setString(2, url);
            query.setString(3, legenda);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirDocumentoUsuario(String legenda, String url, Usuario usuario, int status, int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO documento_usuario (usuario_cpf, url, legenda, status, documento_curso) VALUES ( ? , ? , ?, ?, ?)";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, usuario.getCpf());
            query.setString(2, url);
            query.setString(3, legenda);
            query.setInt(4, status);
            query.setInt(5, curso);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void removerDocumento(int idDcoumento, int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "DELETE FROM documento WHERE id = ?  AND curso = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, idDcoumento);
            query.setInt(2, curso);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void removerDocumentoUsuario(int idDcoumento, String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "DELETE FROM documento_usuario WHERE id = ?  AND usuario_cpf like ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, idDcoumento);
            query.setString(2, cpf);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Documento> getDocumentos(int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Documento> documentos = new ArrayList<Documento>();
            String sql = "SELECT * FROM documento_curso WHERE curso = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso);
            ResultSet resultado = query.executeQuery();
            Documento documento;
            while (resultado.next()) {
                documento = new Documento(
                        resultado.getString("legenda"),
                        resultado.getInt("curso"),
                        resultado.getInt("id"),
                        resultado.getString("url"));
                documentos.add(documento);
            }
            Conexao.close(conexao, query, resultado);
            return documentos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public Documento getDocumento(int idDocumento) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            Documento documento = null;
            String sql = "SELECT * FROM documento_usuario WHERE id = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, idDocumento);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                documento = new Documento(
                        resultado.getString("legenda"),
                        resultado.getString("usuario_cpf"),
                        resultado.getInt("id"),
                        resultado.getString("url"),
                        new Date(resultado.getDate("data_insercao").getTime()),
                        resultado.getInt("status"));
            }
            Conexao.close(conexao, query, resultado);
            return documento;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizarStatusDocumento(Documento documento) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE documento_usuario SET status = ? WHERE id = ? ";
            PreparedStatement stm = conexao.prepareStatement(sql);
            stm.setInt(1, documento.getStatus());
            stm.setInt(2, documento.getId());
            stm.executeUpdate();

            Conexao.close(conexao, stm);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Documento> getDocumentosUsuario(String cpfUsuario, int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Documento> documentos = new ArrayList<Documento>();
            String sql = "SELECT * FROM documento_usuario WHERE usuario_cpf = ? AND documento_curso = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpfUsuario);
            query.setInt(2, numeroCurso);
            ResultSet resultado = query.executeQuery();
            Documento documento;
            while (resultado.next()) {
                documento = new Documento(
                        resultado.getString("legenda"),
                        resultado.getString("usuario_cpf"),
                        resultado.getInt("id"),
                        resultado.getString("url"),
                        new Date(resultado.getDate("data_insercao").getTime()),
                        resultado.getInt("status"));
                documentos.add(documento);
            }
            Conexao.close(conexao, query, resultado);
            return documentos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ArrayList<Documento> getDocumentosIncorretosUsuario(String cpfUsuario, int numeroCurso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<Documento> documentos = new ArrayList<Documento>();
            String sql = "SELECT * FROM documento_usuario WHERE usuario_cpf = ? AND status = 1 AND documento_curso = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpfUsuario);
            query.setInt(2, numeroCurso);
            ResultSet resultado = query.executeQuery();
            Documento documento;
            while (resultado.next()) {
                documento = new Documento(
                        resultado.getString("legenda"),
                        resultado.getString("usuario_cpf"),
                        resultado.getInt("id"),
                        resultado.getString("url"),
                        new Date(resultado.getDate("data_insercao").getTime()),
                        resultado.getInt("status"));
                documentos.add(documento);
            }
            Conexao.close(conexao, query, resultado);
            return documentos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    /* Não é mais necessária após a mudança na regra de negócio
     public ArrayList<Documento> getDocumentosInseridosRecursoUsuario(String cpfUsuario) throws SQLException {
     Connection conexao = Conexao.getConexao();
     try {
     ArrayList<Documento> documentos = new ArrayList<Documento>();
     String sql = "SELECT * FROM documento_usuario WHERE usuario_cpf = ? AND status = 2";
     PreparedStatement query = conexao.prepareStatement(sql);
     query.setString(1, cpfUsuario);
     ResultSet resultado = query.executeQuery();
     Documento documento;
     while (resultado.next()) {
     documento = new Documento(
     resultado.getString("legenda"),
     resultado.getString("usuario_cpf"),
     resultado.getInt("id"),
     resultado.getString("url"),
     new Date(resultado.getDate("data_insercao").getTime()),
     resultado.getInt("status"));
     documentos.add(documento);
     }
     Conexao.close(conexao, query, resultado);
     return documentos;
     } catch (SQLException ex) {
     Conexao.close(conexao, ex);
     throw ex;
     }
     }*/
    public ArrayList<CoordenadorDeCurso> getCoordenadoresDeCurso() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            ArrayList<CoordenadorDeCurso> coordenadoresDeCurso = new ArrayList<CoordenadorDeCurso>();
            String sql = "SELECT * FROM coordenador_de_curso order by nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            while (resultado.next()) {
                CoordenadorDeCurso coordenador = new CoordenadorDeCurso();
                coordenador.setCpf(resultado.getString("cpf"));
                coordenador.setNome(resultado.getString("nome"));
                coordenador.setSobrenome(resultado.getString("sobrenome"));
                coordenadoresDeCurso.add(coordenador);
            }
            Conexao.close(conexao, query, resultado);
            return coordenadoresDeCurso;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public String inserirPermissao(String cpf, int permissao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT nome FROM usuario WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                String sql2 = "INSERT INTO usuario_is_funcoes (usuario_cpf, funcoes_id) VALUES ( ? , ? )";
                PreparedStatement query2 = conexao.prepareStatement(sql2);
                query2.setString(1, cpf);
                query2.setInt(2, permissao);
                query2.executeUpdate();
                query2.close();
                return "A permissão para o usuário " + resultado.getString("nome") + " foi concedida com sucesso!";
            }
            Conexao.close(conexao, query, resultado);
            return "CPF de usuário não encontrado";
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        } finally {
            Conexao.close(conexao);
        }
    }

    public boolean verificarPermissao(String cpf, int permissao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT funcoes_id FROM usuario_is_funcoes WHERE usuario_cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet resultado = query.executeQuery();
            boolean retorno = false;
            if (resultado.next()) {
                retorno = true;
            }
            Conexao.close(conexao, query, resultado);
            return retorno;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void removerPermissao(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "DELETE from usuario_is_funcoes WHERE usuario_cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirCoordenacao(String cpf, int curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO coordenador_tem_curso (coordenadorpedagogico_cpf, curso_numero) VALUES ( ? , ? )";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            query.setInt(2, curso);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    private String vetorToString(String[] ordenacao) {
        if (ordenacao != null && ordenacao.length > 0) {
            String ordem = " ORDER BY ";
            int count = 1;
            for (String s : ordenacao) {
                ordem += s + " ASC ";
                if (count < ordenacao.length) {
                    ordem += " , ";
                    count++;
                }
            }
            return ordem;
        } else {
            return null;
        }
    }

    public List<Estado> getEstados() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Estado> estados = new ArrayList<Estado>();
            String sql = "SELECT * FROM estado ORDER BY uf";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Estado estado = new Estado(result.getInt("id"),
                        result.getString("nome"),
                        result.getString("uf"));
                estados.add(estado);
            }
            Conexao.close(conexao, query, result);
            return estados;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Cidade> getCidades(int estadoId) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Cidade> cidades = new ArrayList<Cidade>();
            String sql = "SELECT * FROM cidade WHERE estado = ? ORDER BY nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, estadoId);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Cidade cidade = new Cidade(result.getInt("id"),
                        result.getString("nome"));
                cidades.add(cidade);
            }
            Conexao.close(conexao, query, result);
            return cidades;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Nivel> getNiveis() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Nivel> niveis = new ArrayList<Nivel>();
            String sql = "SELECT * FROM tipo_curso_nivel ORDER BY id";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Nivel nivel = new Nivel(result.getInt("id"),
                        result.getString("nome"));
                niveis.add(nivel);
            }
            Conexao.close(conexao, query, result);
            return niveis;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoDemanda> getCursosDemanda() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoDemanda> cursos = new ArrayList<CursoDemanda>();
            String sql = "SELECT * FROM demanda_cursos ORDER BY nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoDemanda curso = new CursoDemanda(result.getInt("id"),
                        result.getString("nome"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoDemanda> getCursosIpes() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoDemanda> cursos = new ArrayList<CursoDemanda>();
            String sql = "SELECT * FROM siead_cursos ORDER BY curso";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoDemanda curso = new CursoDemanda(result.getInt("id_curso"),
                        result.getString("curso"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Grau> getGraus() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Grau> graus = new ArrayList<Grau>();
            String sql = "SELECT * FROM siead_graus ORDER BY id_grau";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Grau grau = new Grau(result.getInt("id_grau"),
                        result.getString("grau"));
                graus.add(grau);
            }
            Conexao.close(conexao, query, result);
            return graus;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Modalidade> getModalidades() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Modalidade> modalidades = new ArrayList<Modalidade>();
            String sql = "SELECT * FROM siead_modalidades ORDER BY id_modalidade";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Modalidade modalidade = new Modalidade(result.getInt("id_modalidade"),
                        result.getString("modalidade"));
                modalidades.add(modalidade);
            }
            Conexao.close(conexao, query, result);
            return modalidades;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Status> getStatus() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Status> status = new ArrayList<Status>();
            String sql = "SELECT * FROM siead_tempos ORDER BY id_tempo";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Status stat = new Status(result.getInt("id_tempo"),
                        result.getString("tempo"));
                status.add(stat);
            }
            Conexao.close(conexao, query, result);
            return status;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Demanda> getDemandas(Usuario usuario) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Demanda> demandas = new ArrayList<Demanda>();
            String sql = "SELECT * FROM demanda WHERE usuario = ? ORDER BY id";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, usuario.getCpf());
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Demanda demanda = new Demanda(result.getInt("id"),
                        result.getString("usuario"),
                        result.getInt("nivel"),
                        result.getInt("curso"),
                        result.getInt("modalidade"),
                        result.getInt("cidade"),
                        result.getInt("estado"),
                        result.getInt("polo"),
                        result.getBoolean("professor_publico"),
                        result.getInt("ano"),
                        new Date(result.getTimestamp("data").getTime()));
                demandas.add(demanda);
            }
            Conexao.close(conexao, query, result);
            return demandas;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Demanda> getDemandas(Usuario usuario, int ano) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Demanda> demandas = new ArrayList<Demanda>();
            String sql = "SELECT * FROM demanda WHERE usuario = ? AND ano = ? ORDER BY id";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, usuario.getCpf());
            query.setInt(2, ano);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Demanda demanda = new Demanda(result.getInt("id"),
                        result.getString("usuario"),
                        result.getInt("nivel"),
                        result.getInt("curso"),
                        result.getInt("modalidade"),
                        result.getInt("cidade"),
                        result.getInt("estado"),
                        result.getInt("polo"),
                        result.getBoolean("professor_publico"),
                        result.getInt("ano"),
                        new Date(result.getTimestamp("data").getTime()));
                demandas.add(demanda);
            }
            Conexao.close(conexao, query, result);
            return demandas;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void insereDemanda(Demanda demanda) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO demanda ( "
                    + " usuario,"
                    + " nivel,"
                    + " curso,"
                    + " modalidade,"
                    + " cidade,"
                    + " estado,"
                    + " polo,"
                    + " professor_publico,"
                    + " ano,"
                    + " data "
                    + " ) VALUES ( "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?,  "
                    + " ?)  ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, demanda.getCpfUsuario());
            query.setInt(2, demanda.getIdNivel());
            query.setInt(3, demanda.getIdCurso());
            query.setInt(4, demanda.getIdModalidade());
            query.setInt(5, demanda.getIdCidade());
            query.setInt(6, demanda.getIdEstado());
            query.setInt(7, demanda.getPolo());
            query.setBoolean(8, demanda.isProfessorPublico());
            query.setInt(9, demanda.getAno());
            query.setTimestamp(10, new java.sql.Timestamp(demanda.getData().getTime()));
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizaDemanda(Demanda demanda) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE demanda SET "
                    + " usuario = ? ,"
                    + " nivel = ? ,"
                    + " curso = ? ,"
                    + " modalidade = ? ,"
                    + " cidade = ? ,"
                    + " estado = ? ,"
                    + " polo = ? ,"
                    + " professor_publico = ? ,"
                    + " ano = ? ,"
                    + " data = ? "
                    + " WHERE id = ?";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, demanda.getCpfUsuario());
            query.setInt(2, demanda.getIdNivel());
            query.setInt(3, demanda.getIdCurso());
            query.setInt(4, demanda.getIdModalidade());
            query.setInt(5, demanda.getIdCidade());
            query.setInt(6, demanda.getIdEstado());
            query.setInt(7, demanda.getPolo());
            query.setBoolean(8, demanda.isProfessorPublico());
            query.setInt(9, demanda.getAno());
            query.setTimestamp(10, new java.sql.Timestamp(demanda.getData().getTime()));
            query.setInt(11, demanda.getId());
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Integer> getAnosDemandas() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Integer> anos = new ArrayList<Integer>();
            String sql = "SELECT distinct(ano) AS ano FROM demanda ORDER BY ano DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                int ano = result.getInt("ano");
                anos.add(ano);
            }
            Conexao.close(conexao, query, result);
            return anos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoIPES> getCursosIpes(GestorIPES gestor) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoIPES> cursos = new ArrayList<CursoIPES>();
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " WHERE i.id_ipes = ? "
                    + " GROUP BY i.id_ipes, i.ipes, n.id, n.nome, c.id_curso, c.curso, g.id_grau, g.grau, m.id_modalidade, m.modalidade, t.id_tempo, t.tempo "
                    + " ORDER BY n.id, c.id_curso, g.id_grau, m.id_modalidade, t.id_tempo ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, gestor.getIpesId());
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoIPES curso = new CursoIPES(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public CursoIPES getCursoIpes(int nivel, int curso, int grau, int modalidade, int status, int ipes) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " WHERE cg.id_nivel = ? "
                    + " AND cg.id_curso = ? "
                    + " AND cg.id_grau = ? "
                    + " AND cg.id_modalidade = ? "
                    + " AND cg.id_tempo = ? "
                    + " AND cg.id_ipes = ? "
                    + " GROUP BY i.id_ipes, i.ipes, n.id, n.nome, c.id_curso, c.curso, g.id_grau, g.grau, m.id_modalidade, m.modalidade, t.id_tempo, t.tempo "
                    + " ORDER BY n.id, c.id_curso, g.id_grau, m.id_modalidade, t.id_tempo ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, nivel);
            query.setInt(2, curso);
            query.setInt(3, grau);
            query.setInt(4, modalidade);
            query.setInt(5, status);
            query.setInt(6, ipes);
            ResultSet result = query.executeQuery();
            if (result.next()) {
                CursoIPES cursoIpes = new CursoIPES(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"));
                Conexao.close(conexao, query, result);
                return cursoIpes;
            } else {
                Conexao.close(conexao, query, result);
                return null;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoIPESMunicipio> getCursosIpesMunicipios(GestorIPES gestor) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoIPESMunicipio> cursos = new ArrayList<CursoIPESMunicipio>();
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo, "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " INNER JOIN siead_municipios mun ON mun.id_municipio = cg.id_municipio "
                    + " WHERE i.id_ipes = ? "
                    + " AND t.id_tempo <> 2 "
                    + " ORDER BY n.id, c.curso, g.id_grau, m.modalidade, t.tempo, mun.municipio ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, gestor.getIpesId());
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoIPESMunicipio curso = new CursoIPESMunicipio(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"),
                        result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public CursoIPESMunicipio getCursosIpesMunicipios(int id) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo, "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " INNER JOIN siead_municipios mun ON mun.id_municipio = cg.id_municipio "
                    + " WHERE cg.id = ? "
                    + " ORDER BY n.id, c.curso, g.id_grau, m.modalidade, t.tempo, mun.municipio ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, id);
            ResultSet result = query.executeQuery();
            if (result.next()) {
                CursoIPESMunicipio curso = new CursoIPESMunicipio(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"),
                        result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                Conexao.close(conexao, query, result);
                return curso;
            } else {
                Conexao.close(conexao, query, result);
                return null;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoIPESMunicipio> getCursosIpesMunicipios() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoIPESMunicipio> cursos = new ArrayList<CursoIPESMunicipio>();
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo, "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " INNER JOIN siead_municipios mun ON mun.id_municipio = cg.id_municipio "
                    + " WHERE t.id_tempo <> 2 "
                    + " ORDER BY n.id, c.curso, g.id_grau, m.modalidade, t.tempo, i.id_ipes, mun.municipio ";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoIPESMunicipio curso = new CursoIPESMunicipio(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"),
                        result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<CursoIPESMunicipio> getCursosIpesOrdenadoMunicipios() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<CursoIPESMunicipio> cursos = new ArrayList<CursoIPESMunicipio>();
            String sql = "SELECT cg.id, "
                    + " i.id_ipes, i.ipes, "
                    + " n.id, n.nome, "
                    + " c.id_curso, c.curso, "
                    + " g.id_grau, g.grau, "
                    + " m.id_modalidade, m.modalidade, "
                    + " t.id_tempo, t.tempo, "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_ipes i ON i.id_ipes = cg.id_ipes "
                    + " INNER JOIN tipo_curso_nivel n ON n.id = cg.id_nivel "
                    + " INNER JOIN siead_cursos c ON c.id_curso = cg.id_curso "
                    + " INNER JOIN siead_graus g ON g.id_grau = cg.id_grau "
                    + " INNER JOIN siead_modalidades m ON m.id_modalidade = cg.id_modalidade "
                    + " INNER JOIN siead_tempos t ON t.id_tempo = cg.id_tempo "
                    + " INNER JOIN siead_municipios mun ON mun.id_municipio = cg.id_municipio "
                    + " WHERE t.id_tempo <> 2 "
                    + " ORDER BY n.id, mun.municipio, c.curso, g.id_grau, m.modalidade, t.tempo, i.id_ipes ";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                CursoIPESMunicipio curso = new CursoIPESMunicipio(result.getInt("cg.id"),
                        result.getInt("i.id_ipes"),
                        result.getString("i.ipes"),
                        result.getInt("n.id"),
                        result.getString("n.nome"),
                        result.getInt("c.id_curso"),
                        result.getString("c.curso"),
                        result.getInt("g.id_grau"),
                        result.getString("g.grau"),
                        result.getInt("m.id_modalidade"),
                        result.getString("m.modalidade"),
                        result.getInt("t.id_tempo"),
                        result.getString("t.tempo"),
                        result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                cursos.add(curso);
            }
            Conexao.close(conexao, query, result);
            return cursos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void inserirCursoIpes(CursoIPESMunicipio curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO siead_cursos_goias ("
                    + " id_ipes, "
                    + " id_nivel, "
                    + " id_curso, "
                    + " id_grau, "
                    + " id_modalidade, "
                    + " id_tempo, "
                    + " id_municipio "
                    + " ) VALUES ( "
                    + " ?, "
                    + " ?, "
                    + " ?, "
                    + " ?, "
                    + " ?, "
                    + " ?, "
                    + " ? "
                    + " ) ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso.getIpesId());
            query.setInt(2, curso.getNivelId());
            query.setInt(3, curso.getCursoId());
            query.setInt(4, curso.getGrauId());
            query.setInt(5, curso.getModalidadeId());
            query.setInt(6, curso.getTempoId());
            query.setInt(7, curso.getMunicipioId());
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void removerCursoIpes(CursoIPESMunicipio curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "DELETE FROM siead_cursos_goias "
                    + " WHERE id_ipes = ? "
                    + " AND id_nivel = ? "
                    + " AND id_curso = ? "
                    + " AND id_grau = ? "
                    + " AND id_modalidade = ? "
                    + " AND id_tempo = ? "
                    + " AND id_municipio = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso.getIpesId());
            query.setInt(2, curso.getNivelId());
            query.setInt(3, curso.getCursoId());
            query.setInt(4, curso.getGrauId());
            query.setInt(5, curso.getModalidadeId());
            query.setInt(6, curso.getTempoId());
            query.setInt(7, curso.getMunicipioId());
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public String getUltimaModificacaoIpes(int idIpes) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT modificado FROM siead_ipes WHERE id_ipes = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, idIpes);
            ResultSet result = query.executeQuery();
            try {
                if (result.next()) {
                    Date modificado = new Date(result.getTimestamp("modificado").getTime());
                    SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy HH:mm");
                    Conexao.close(conexao, query, result);
                    return formatter.format(modificado);
                } else {
                    Conexao.close(conexao, query, result);
                    return "-";
                }
            } catch (Exception ex) {
                Conexao.close(conexao, query, result);
                return "-";
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizarUltimaModificacaoIpes(int idIpes) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE siead_ipes SET modificado = now() WHERE id_ipes = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, idIpes);
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Municipio> getMunicipios(CursoIPES curso) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Municipio> municipios = new ArrayList<Municipio>();
            String sql = "SELECT "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_cursos_goias cg "
                    + " INNER JOIN siead_municipios mun ON mun.id_municipio = cg.id_municipio "
                    + " WHERE "
                    + " cg.id_ipes = ? "
                    + " AND cg.id_nivel = ? "
                    + " AND cg.id_curso = ? "
                    + " AND cg.id_grau = ? "
                    + " AND cg.id_modalidade = ? "
                    + " AND cg.id_tempo = ? "
                    + " ORDER BY mun.id_municipio ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setInt(1, curso.getIpesId());
            query.setInt(2, curso.getNivelId());
            query.setInt(3, curso.getCursoId());
            query.setInt(4, curso.getGrauId());
            query.setInt(5, curso.getModalidadeId());
            query.setInt(6, curso.getTempoId());
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Municipio municipio = new Municipio(result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                municipios.add(municipio);
            }
            Conexao.close(conexao, query, result);
            return municipios;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Municipio> getMunicipios() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            List<Municipio> municipios = new ArrayList<Municipio>();
            String sql = "SELECT "
                    + " mun.id_municipio, mun.municipio "
                    + " FROM siead_municipios mun "
                    + " ORDER BY mun.municipio ";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            while (result.next()) {
                Municipio municipio = new Municipio(result.getInt("mun.id_municipio"),
                        result.getString("mun.municipio"));
                municipios.add(municipio);
            }
            Conexao.close(conexao, query, result);
            return municipios;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void adicionarCursoIpes(String nomeCurso, GestorIPES gestor) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO solicitacao_curso_ipes ("
                    + " gestor_ipes, "
                    + " nome_curso, "
                    + " data "
                    + " ) VALUES ( "
                    + " ?, "
                    + " ?, "
                    + " ? "
                    + " ) ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, gestor.getCpf());
            query.setString(2, nomeCurso);
            query.setTimestamp(3, new java.sql.Timestamp(new Date().getTime()));
            query.executeUpdate();
            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Polo> getMunicipiosDemanda() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            //String sql = "SELECT distinct(d.cidade) AS id, c.nome, e.uf AS uf FROM bridge.demanda d INNER JOIN bridge.cidade c ON c.id=d.cidade INNER JOIN estado e ON e.id = c.estado ORDER BY c.nome";
            String sql = "SELECT distinct(d.cidade) AS id, c.nome, e.uf AS uf FROM demanda d INNER JOIN cidade c ON c.id=d.cidade INNER JOIN estado e ON e.id = c.estado ORDER BY c.nome";

            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            ArrayList<Polo> polos = new ArrayList<Polo>();
            while (result.next()) {
                Polo p = new Polo(result.getInt("id"), result.getString("nome"));
                p.setUf(result.getString("uf"));
                polos.add(p);
            }
            Conexao.close(conexao, query, result);
            return polos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<Polo> getPolosDemanda() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT distinct(d.polo) AS id, p.nome  FROM bridge.demanda d INNER JOIN bridge.polo p ON p.numero = d.polo ";
            sql += " ORDER BY p.nome";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet result = query.executeQuery();
            ArrayList<Polo> polos = new ArrayList<Polo>();
            while (result.next()) {
                Polo p = new Polo(result.getInt("id"), result.getString("nome"));
                polos.add(p);
            }
            Conexao.close(conexao, query, result);
            return polos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public static void main(String[] args) throws SQLException {
    }

    /**
     * *********************************************
     * ********** FUNÇÕES IPTSP ********************
     * *********************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Funções IPTSP.">
    public void cadastraIPTSP(String nome, java.util.Date nascimento, String rg, String orgao_expedidor, String cpf, String rua, String complemento, String bairro, String cidade, String estado, String cep, String telefone_residencial, String telefone_celular, String email, String polo, boolean graduacao, String graduacao_instituicao, String graduacao_curso, Date graduacao_inicio, Date graduacao_conclusao, boolean posgraduacao, String posgraduacao_instituicao, String posgraduacao_curso, Date posgraduacao_inicio, Date posgraduacao_conclusao, boolean outra, String outra_formacao, String outra_instituicao, String outra_curso, Date outra_inicio, Date outra_conclusao, String polo_pos, String tipo_curso, int ch_16_40, int ch_41_80, int ch_81_120, int ch_mais_120, int c_informatica, String atuacao_instituicao, String atuacao_area, Date atuacao_periodo_inicio, Date atuacao_periodo_fim, String esfera_sus, String vinculo_sus, boolean outros1, boolean outros2, boolean outros3, boolean outros4, boolean outros5, boolean outros6, boolean aett1, boolean aett2, boolean aett3, boolean aett4, boolean aett5) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "INSERT INTO formulario_iptsp (nome, nascimento, rg, orgao_expedidor, cpf, rua, complemento, bairro, cidade, estado, cep, telefone_residencial, telefone_celular, email, polo,"
                    + "graduacao, graduacao_instituicao, graduacao_curso, graduacao_inicio, graduacao_conclusao, posgraduacao, posgraduacao_instituicao, posgraduacao_curso,"
                    + "posgraduacao_inicio, posgraduacao_conclusao, outra, outra_formacao, outra_instituicao, outra_curso, outra_inicio, outra_conclusao, polo_pos, tipo_curso,"
                    + "ch_16_40, ch_41_80, ch_81_120, ch_mais_120, c_informatica, atuacao_instituicao, atuacao_area, atuacao_periodo_inicio, atuacao_periodo_fim, esfera_sus,"
                    + "vinculo_sus, outros1, outros2, outros3, outros4, outros5, outros6, aett1, aett2, aett3, aett4, aett5) "
                    + " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, nome);
            query.setDate(2, new java.sql.Date(nascimento.getTime()));
            query.setString(3, rg);
            query.setString(4, orgao_expedidor);
            query.setString(5, cpf);
            query.setString(6, rua);
            query.setString(7, complemento);
            query.setString(8, bairro);
            query.setString(9, cidade);
            query.setString(10, estado);
            query.setString(11, cep);
            query.setString(12, telefone_residencial);
            query.setString(13, telefone_celular);
            query.setString(14, email);
            query.setString(15, polo);
            query.setBoolean(16, graduacao);
            query.setString(17, graduacao_instituicao);
            query.setString(18, graduacao_curso);
            if (graduacao_inicio != null) {
                query.setDate(19, new java.sql.Date(graduacao_inicio.getTime()));
            } else {
                query.setDate(19, null);
            }
            if (graduacao_conclusao != null) {
                query.setDate(20, new java.sql.Date(graduacao_conclusao.getTime()));
            } else {
                query.setDate(20, null);
            }
            query.setBoolean(21, posgraduacao);
            query.setString(22, posgraduacao_instituicao);
            query.setString(23, posgraduacao_curso);
            if (posgraduacao_inicio != null) {
                query.setDate(24, new java.sql.Date(posgraduacao_inicio.getTime()));
            } else {
                query.setDate(24, null);
            }
            if (posgraduacao_conclusao != null) {
                query.setDate(25, new java.sql.Date(posgraduacao_conclusao.getTime()));
            } else {
                query.setDate(25, null);
            }
            query.setBoolean(26, outra);
            query.setString(27, outra_formacao);
            query.setString(28, outra_instituicao);
            query.setString(29, outra_curso);
            if (outra_inicio != null) {
                query.setDate(30, new java.sql.Date(outra_inicio.getTime()));
            } else {
                query.setDate(30, null);
            }
            if (outra_conclusao != null) {
                query.setDate(31, new java.sql.Date(outra_conclusao.getTime()));
            } else {
                query.setDate(31, null);
            }
            query.setString(32, polo_pos);
            query.setString(33, tipo_curso);
            query.setInt(34, ch_16_40);
            query.setInt(35, ch_41_80);
            query.setInt(36, ch_81_120);
            query.setInt(37, ch_mais_120);
            query.setInt(38, c_informatica);
            query.setString(39, atuacao_instituicao);
            query.setString(40, atuacao_area);
            if (atuacao_periodo_inicio != null) {
                query.setDate(41, new java.sql.Date(atuacao_periodo_inicio.getTime()));
            } else {
                query.setDate(41, null);
            }
            if (atuacao_periodo_fim != null) {
                query.setDate(42, new java.sql.Date(atuacao_periodo_fim.getTime()));
            } else {
                query.setDate(42, null);
            }
            query.setString(43, esfera_sus);
            query.setString(44, vinculo_sus);
            query.setBoolean(45, outros1);
            query.setBoolean(46, outros2);
            query.setBoolean(47, outros3);
            query.setBoolean(48, outros4);
            query.setBoolean(49, outros5);
            query.setBoolean(50, outros6);
            query.setBoolean(51, aett1);
            query.setBoolean(52, aett2);
            query.setBoolean(53, aett3);
            query.setBoolean(54, aett4);
            query.setBoolean(55, aett5);

            query.executeUpdate();

            Conexao.close(conexao, query);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isUsuarioCadastradoIPTSP(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                Conexao.close(conexao, query, resultado);
                return true;
            } else {
                Conexao.close(conexao, query, resultado);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isUsuarioCadastradoIPTSP2(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp2 WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                Conexao.close(conexao, query, resultado);
                return true;
            } else {
                Conexao.close(conexao, query, resultado);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosIPTSP() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                Conexao.close(conexao, query, resultado);
                return resultado;
            }
            Conexao.close(conexao, query, resultado);
            return null;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosIPTSP2() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp2 ORDER BY polo";
            PreparedStatement query = conexao.prepareStatement(sql);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                return resultado;
            }
            Conexao.close(conexao, query, resultado);
            return null;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getMatriculadosIPTSP2() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp2 WHERE matricula_efetuada = ? ORDER BY polo";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            pstmt.setBoolean(1, true);
            ResultSet result = pstmt.executeQuery();
            return result;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosIPTSP2PorPolo(String polo) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM formulario_iptsp2 WHERE polo like ? ORDER BY matricula_efetuada DESC";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, polo);
            ResultSet resultado = query.executeQuery();
            return resultado;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public int cadastraIPTSP2(String sql, String nome, String nascimento, String rg, String orgao_expedidor, String cpf, String rua, String complemento, String bairro, String cidade, String estado, String cep, String telefone_residencial, String telefone_celular, String email, String polo, String esfera_sus, String atividade_profissional, String atividade_profissional_instituicao, String atividade_profissional_area, String atividade_profissional_inicio, String graduacao, String pos_especializacao, String pos_mestrado, String pos_doutorado, String formacao_outros, String area_interesse, String area_inscricao, String motivacao, int m1_1, int m1_2, int m1_3, int m1_4, int m1_5, int m1_6, int m2_1, int m2_2, int m2_3, int m2_4, int m2_5, int m3_1, int m3_2, int m3_3, int m3_4, int m3_5, int m3_6, int m3_7, int m3_8, int m3_9, int m3_10, int m3_11, String extensao_arquivo1, String extensao_arquivo2, String extensao_arquivo3, String extensao_arquivo4) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            PreparedStatement pstmt = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, nome);
            pstmt.setString(2, nascimento);
            pstmt.setString(3, rg);
            pstmt.setString(4, orgao_expedidor);
            pstmt.setString(5, cpf);
            pstmt.setString(6, rua);
            pstmt.setString(7, complemento);
            pstmt.setString(8, bairro);
            pstmt.setString(9, cidade);
            pstmt.setString(10, estado);
            pstmt.setString(11, cep);
            pstmt.setString(12, telefone_residencial);
            pstmt.setString(13, telefone_celular);
            pstmt.setString(14, email);
            pstmt.setString(15, polo);
            pstmt.setString(16, esfera_sus);
            pstmt.setString(17, atividade_profissional);
            pstmt.setString(18, atividade_profissional_instituicao);
            pstmt.setString(19, atividade_profissional_area);
            pstmt.setString(20, atividade_profissional_inicio);
            pstmt.setString(21, graduacao);
            pstmt.setString(22, pos_especializacao);
            pstmt.setString(23, pos_mestrado);
            pstmt.setString(24, pos_doutorado);
            pstmt.setString(25, formacao_outros);
            pstmt.setString(26, area_interesse);
            pstmt.setString(27, area_inscricao);
            pstmt.setString(28, motivacao);
            pstmt.setInt(29, m1_1);
            pstmt.setInt(30, m1_2);
            pstmt.setInt(31, m1_3);
            pstmt.setInt(32, m1_4);
            pstmt.setInt(33, m1_5);
            pstmt.setInt(34, m1_6);
            pstmt.setInt(35, m2_1);
            pstmt.setInt(36, m2_2);
            pstmt.setInt(37, m2_3);
            pstmt.setInt(38, m2_4);
            pstmt.setInt(39, m2_5);
            pstmt.setInt(40, m3_1);
            pstmt.setInt(41, m3_2);
            pstmt.setInt(42, m3_3);
            pstmt.setInt(43, m3_4);
            pstmt.setInt(44, m3_5);
            pstmt.setInt(45, m3_6);
            pstmt.setInt(46, m3_7);
            pstmt.setInt(47, m3_8);
            pstmt.setInt(48, m3_9);
            pstmt.setInt(49, m3_10);
            pstmt.setInt(50, m3_11);
            pstmt.setString(51, extensao_arquivo1);
            pstmt.setString(52, extensao_arquivo2);
            pstmt.setString(53, extensao_arquivo3);
            pstmt.setString(54, extensao_arquivo4);

            pstmt.executeUpdate();
            ResultSet result = pstmt.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            Conexao.close(conexao, pstmt, result);
            return result_id;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public InscritoIPTSP getInscritoIPTSP2porCPF(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT  cpf,  nome,  rua,  complemento,  "
                    + "bairro,  cidade,  estado,  cep,  telefone_residencial,  telefone_celular,  "
                    + "email,  polo FROM formulario_iptsp2 WHERE cpf = ? ";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            pstmt.setString(1, cpf);
            ResultSet result = pstmt.executeQuery();
            InscritoIPTSP inscrito = null;
            if (result.next()) {
                inscrito = new InscritoIPTSP(result.getString("cpf"),
                        result.getString("nome"), result.getString("rua"),
                        result.getString("complemento"), result.getString("bairro"),
                        result.getString("cidade"), result.getString("estado"),
                        result.getString("cep"), result.getString("telefone_residencial"),
                        result.getString("telefone_celular"), result.getString("email"),
                        result.getString("polo"));
            }
            Conexao.close(conexao, pstmt, result);
            return inscrito;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public void atualizaInscritoIPTSP2(InscritoIPTSP inscrito) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "UPDATE formulario_iptsp2 "
                    + " SET "
                    + " rua = ?, "
                    + " complemento = ?, "
                    + " bairro = ?, "
                    + " cidade = ?, "
                    + " estado = ?, "
                    + " cep = ?, "
                    + " telefone_residencial = ?, "
                    + " telefone_celular = ?, "
                    + " email = ?, "
                    + " extensao_arquivo1 = ?, "
                    + " extensao_arquivo2 = ?, "
                    + " extensao_arquivo3 = ?, "
                    + " matricula_efetuada = ?, "
                    + " extensao_arquivo5 = ?, "
                    + " extensao_arquivo6 = ?, "
                    + " extensao_arquivo7 = ? "
                    + " WHERE cpf = ? ";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            pstmt.setString(1, inscrito.getRua());
            pstmt.setString(2, inscrito.getComplemento());
            pstmt.setString(3, inscrito.getBairro());
            pstmt.setString(4, inscrito.getCidade());
            pstmt.setString(5, inscrito.getEstado());
            pstmt.setString(6, inscrito.getCep());
            pstmt.setString(7, inscrito.getTelefone_residencial());
            pstmt.setString(8, inscrito.getTelefone_celular());
            pstmt.setString(9, inscrito.getEmail());
            pstmt.setString(10, inscrito.getExtensao_arquivo5());
            pstmt.setString(11, inscrito.getExtensao_arquivo6());
            pstmt.setString(12, inscrito.getExtensao_arquivo7());
            pstmt.setBoolean(13, inscrito.isMatriculaEfetuada());
            pstmt.setString(14, inscrito.getExtensao_arquivo5());
            pstmt.setString(15, inscrito.getExtensao_arquivo6());
            pstmt.setString(16, inscrito.getExtensao_arquivo7());
            pstmt.setString(17, inscrito.getCpf());
            pstmt.executeUpdate();
            Conexao.close(conexao, pstmt);
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //</editor-fold>

    /**
     * *********************************************
     * ********** FUNÇÕES ENFERMAGEM ***************
     * *********************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Funções Enfermagem.">
    public boolean isUsuarioCadastradoEnfermagem(String cpf, String cursonivel) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM " + CFG.BD_AMST + " WHERE cpf = ? AND cursonivel = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            query.setString(2, cursonivel);
            ResultSet resultado = query.executeQuery();
            if (resultado.next()) {
                Conexao.close(conexao, query, resultado);
                return true;
            } else {
                Conexao.close(conexao, query, resultado);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public int cadastraENFERMAGEM(String sql, String nome, String endereco, String bairro, String cep, String cidade, String estado, String telfixo, String telcel, String email, String pai, String mae, Date nascimento, String sexo, String cidadenasc, String estadonasc, String pais, String nacionalidade, String estadocivil, String rg, String ufrg, Date emissaorg, String cpf, String titulo, String uftitulo, String zonatitulo, String secaotitulo, String curso, String instituicaocurso, Date iniciocurso, Date fimcurso, String cursonivel, String localtrabalho, String teltrabalho, String cargotrabalho, String cidadetrabalho, String estadotrabalho, boolean computador, boolean termoedital, String linklattes, String arquivoCertificadoCurso, String arquivoIndicacaoTrabalho, String emissoridentidade) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            PreparedStatement pstmt = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, nome);
            pstmt.setString(2, endereco);
            pstmt.setString(3, bairro);
            pstmt.setString(4, cep);
            pstmt.setString(5, cidade);
            pstmt.setString(6, estado);
            pstmt.setString(7, telfixo);
            pstmt.setString(8, telcel);
            pstmt.setString(9, email);
            pstmt.setString(10, pai);
            pstmt.setString(11, mae);
            pstmt.setDate(12, new java.sql.Date(nascimento.getTime()));
            pstmt.setString(13, cidadenasc);
            pstmt.setString(14, estadonasc);
            pstmt.setString(15, sexo);
            pstmt.setString(16, pais);
            pstmt.setString(17, nacionalidade);
            pstmt.setString(18, estadocivil);
            pstmt.setString(19, rg);
            pstmt.setString(20, ufrg);
            pstmt.setDate(21, new java.sql.Date(emissaorg.getTime()));
            pstmt.setString(22, cpf);
            pstmt.setString(23, titulo);
            pstmt.setString(24, uftitulo);
            pstmt.setString(25, zonatitulo);
            pstmt.setString(26, secaotitulo);
            pstmt.setString(27, curso);
            pstmt.setString(28, instituicaocurso);
            pstmt.setDate(29, new java.sql.Date(iniciocurso.getTime()));
            pstmt.setDate(30, new java.sql.Date(fimcurso.getTime()));
            pstmt.setString(31, cursonivel);
            pstmt.setString(32, localtrabalho);
            pstmt.setString(33, cargotrabalho);
            pstmt.setString(34, cidadetrabalho);
            pstmt.setString(35, estadotrabalho);
            pstmt.setBoolean(36, computador);
            pstmt.setBoolean(37, termoedital);
            pstmt.setString(38, linklattes);
            pstmt.setString(39, arquivoCertificadoCurso);
            pstmt.setString(40, arquivoIndicacaoTrabalho);
            pstmt.setString(41, emissoridentidade);
            pstmt.setString(42, teltrabalho);

            pstmt.executeUpdate();
            ResultSet result = pstmt.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            Conexao.close(conexao, pstmt, result);
            return result_id;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosEnfermagemPorNivel(String cursonivel) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM " + CFG.BD_AMST + " WHERE cursonivel = ? ORDER BY nome";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            pstmt.setString(1, cursonivel);
            ResultSet result = pstmt.executeQuery();
            return result;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //</editor-fold>

    /**
     * *********************************************
     * ********** FUNÇÕES EDSC *********************
     * *********************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Funções EDSC.">
    public boolean isUsuarioCadastradoEDSC(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM bridge.edsc_2013 WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet result = query.executeQuery();
            if (result.next()) {
                Conexao.close(conexao, query, result);
                return true;
            } else {
                Conexao.close(conexao, query, result);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public int cadastraEDSC(String sql, String nome, String endereco, String bairro, String cep, String cidade, String estado, String telefone1, String telefone2, String celular, String email, String pai, String mae, Date nascimento, String sexo, String nacionalidade, String estad_ocivil, String rg, String uf_rg, Date emissao_rg, String cpf, String titulo, String uf_titulo, String zona_titulo, String secao_titulo, Date emissao_titulo, String instituica_formacao, String titulo_formacao, String especialidade_formacao, Date inicio_formacao, Date termino_formacao, String linklattes, boolean li_edital, String arquivo_copia_rg, String arquivo_copia_cpf, String arquivo_copia_visto, String graduacao, String arquivo_copia_diploma, String arquivo_copia_comprovante, String arquivo_copia_declaracao, String arquivo_copia_contracheque, String arquivo_copia_projeto, String arquivo_motivacao) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            query.setString(1, nome);
            query.setString(2, endereco);
            query.setString(3, bairro);
            query.setString(4, cep);
            query.setString(5, cidade);
            query.setString(6, estado);
            query.setString(7, telefone1);
            query.setString(8, telefone2);
            query.setString(9, celular);
            query.setString(10, email);
            query.setString(11, pai);
            query.setString(12, mae);
            query.setDate(13, new java.sql.Date(nascimento.getTime()));
            query.setString(14, sexo);
            query.setString(15, nacionalidade);
            query.setString(16, estad_ocivil);
            query.setString(17, rg);
            query.setString(18, uf_rg);
            query.setDate(19, new java.sql.Date(emissao_rg.getTime()));
            query.setString(20, cpf);
            query.setString(21, titulo);
            query.setString(22, uf_titulo);
            query.setString(23, zona_titulo);
            query.setString(24, secao_titulo);
            query.setDate(25, new java.sql.Date(emissao_titulo.getTime()));
            query.setString(26, instituica_formacao);
            query.setString(27, titulo_formacao);
            query.setString(28, especialidade_formacao);
            query.setDate(29, new java.sql.Date(inicio_formacao.getTime()));
            query.setDate(30, new java.sql.Date(termino_formacao.getTime()));
            query.setString(31, linklattes);
            query.setBoolean(32, li_edital);
            query.setString(33, arquivo_copia_rg);
            query.setString(34, arquivo_copia_cpf);
            query.setString(35, arquivo_copia_visto);
            query.setString(36, graduacao);
            query.setString(37, arquivo_copia_diploma);
            query.setString(38, arquivo_copia_comprovante);
            query.setString(39, arquivo_copia_declaracao);
            query.setString(40, arquivo_copia_projeto);
            query.setString(41, arquivo_copia_contracheque);
            query.setString(42, arquivo_motivacao);
            query.setTimestamp(43, new java.sql.Timestamp(new Date().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            Conexao.close(conexao, query, result);
            return result_id;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosEDSC() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM edsc_2013 ORDER BY nome";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            ResultSet result = pstmt.executeQuery();
            return result;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //</editor-fold>

    /**
     * *********************************************
     * ********** FUNÇÕES ASIS *********************
     * *********************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Funções ASIS2013.">
    public int cadastraASS2013(String sql, String cpf, String nome, Date nascimento, String rg, String orgao_rg, String rua,
            String complemento, String bairro, String cidade, String estado, String telefone, String celular, String email,
            String local_encontro, String vinculo_sus, String atividade_profissional,
            String graduacao, Date graduacao_termino, String especializacao, Date especializacao_termino,
            String mestrado, Date mestrado_termino, String doutorado, Date doutorado_termino, String extensao, Date extensao_termino,
            int m1_1, int m1_2, int m1_3, int m2_1, int m2_2, int m2_3, int m2_4, int m2_5, int m3_1, int m3_2, int m3_3, int m3_4,
            String arquivoCopiaRGCPF, String arquivoDiploma, String arquivoComprovanteSUS, String arquivoCartaLiberacao,
            String arquivoTermoCompromisso, boolean li_edital) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            int indice = 1;
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            query.setString(indice++, cpf);
            query.setString(indice++, nome);
            query.setDate(indice++, new java.sql.Date(nascimento.getTime()));
            query.setString(indice++, rg);
            query.setString(indice++, orgao_rg);
            query.setString(indice++, rua);
            query.setString(indice++, complemento);
            query.setString(indice++, bairro);
            query.setString(indice++, cidade);
            query.setString(indice++, estado);
            query.setString(indice++, telefone);
            query.setString(indice++, celular);
            query.setString(indice++, email);
            query.setString(indice++, local_encontro);
            query.setString(indice++, vinculo_sus);
            query.setString(indice++, atividade_profissional);
            query.setString(indice++, graduacao);
            query.setDate(indice++, new java.sql.Date(graduacao_termino.getTime()));
            query.setString(indice++, especializacao);
            if (especializacao_termino != null) {
                query.setDate(indice++, new java.sql.Date(especializacao_termino.getTime()));
            } else {
                query.setObject(indice++, null);
            }
            query.setString(indice++, mestrado);
            if (mestrado_termino != null) {
                query.setDate(indice++, new java.sql.Date(mestrado_termino.getTime()));
            } else {
                query.setObject(indice++, null);
            }
            query.setString(indice++, doutorado);
            if (doutorado_termino != null) {
                query.setDate(indice++, new java.sql.Date(doutorado_termino.getTime()));
            } else {
                query.setObject(indice++, null);
            }
            query.setString(indice++, extensao);
            if (extensao_termino != null) {
                query.setDate(indice++, new java.sql.Date(extensao_termino.getTime()));
            } else {
                query.setObject(indice++, null);
            }
            query.setInt(indice++, m1_1);
            query.setInt(indice++, m1_2);
            query.setInt(indice++, m1_3);
            query.setInt(indice++, m2_1);
            query.setInt(indice++, m2_2);
            query.setInt(indice++, m2_3);
            query.setInt(indice++, m2_4);
            query.setInt(indice++, m2_5);
            query.setInt(indice++, m3_1);
            query.setInt(indice++, m3_2);
            query.setInt(indice++, m3_3);
            query.setInt(indice++, m3_4);
            query.setString(indice++, arquivoCopiaRGCPF);
            query.setString(indice++, arquivoDiploma);
            query.setString(indice++, arquivoComprovanteSUS);
            query.setString(indice++, arquivoCartaLiberacao);
            query.setString(indice++, arquivoTermoCompromisso);
            query.setBoolean(indice++, li_edital);
            query.setTimestamp(indice++, new java.sql.Timestamp(new Date().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            Conexao.close(conexao, query, result);
            return result_id;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public ResultSet getInscritosASS2013() throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM inscricoes_ass_2013 ORDER BY nome";
            PreparedStatement pstmt = conexao.prepareStatement(sql);
            ResultSet result = pstmt.executeQuery();
            return result;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isUsuarioCadastradoASS2013(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM inscricoes_ass_2013 WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet result = query.executeQuery();
            if (result.next()) {
                Conexao.close(conexao, query, result);
                return true;
            } else {
                Conexao.close(conexao, query, result);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //</editor-fold>
    /* *************************************
     * ***** FUNÇÕES EVENTO CIAR 2013 ******
     * *************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Funções EVENTO CIAR 2013.">

    public int cadastraEventoCiar2013(String sql, String cpf, String nome, String email, boolean isVIP) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            int indice = 1;
            PreparedStatement query = conexao.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            query.setString(indice++, cpf);
            query.setString(indice++, nome);
            query.setString(indice++, email);
            query.setBoolean(indice++, isVIP);
            query.setTimestamp(indice++, new java.sql.Timestamp(new Date().getTime()));

            query.executeUpdate();
            ResultSet result = query.getGeneratedKeys();
            result.first();
            int result_id = result.getInt(1);
            Conexao.close(conexao, query, result);
            return result_id;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public boolean isUsuarioCadastradoEventoCiar2013(String cpf) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM inscricoes_evento_ciar_2013 WHERE cpf = ? ";
            PreparedStatement query = conexao.prepareStatement(sql);
            query.setString(1, cpf);
            ResultSet result = query.executeQuery();
            if (result.next()) {
                Conexao.close(conexao, query, result);
                return true;
            } else {
                Conexao.close(conexao, query, result);
                return false;
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<tela.eventociar.Inscrito> getInscritosVipEventoCiar2013() throws SQLException {
        return getInscritosVipEventoCiar2013(null);
    }

    public List<tela.eventociar.Inscrito> getInscritosVipNoDiaEventoCiar2013() throws SQLException {
        return getInscritosVipEventoCiar2013(true);
    }

    public List<tela.eventociar.Inscrito> getInscritosVipAntesDoEventoCiar2013() throws SQLException {
        return getInscritosVipEventoCiar2013(false);
    }

    private List<tela.eventociar.Inscrito> getInscritosVipEventoCiar2013(Boolean inscricoesNoDia) throws SQLException {
        List<tela.eventociar.Inscrito> inscritos = new ArrayList<tela.eventociar.Inscrito>();
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM inscricoes_evento_ciar_2013_vip ";
            if (inscricoesNoDia != null) {
                if (inscricoesNoDia.booleanValue()) { // Pegar inscrições no dia do evento
                    sql += " WHERE DATE(horario) = ? ";
                } else { // Pegar inscrições antes do evento
                    sql += " WHERE DATE(horario) < ? ";
                }
            }
            PreparedStatement query = conexao.prepareStatement(sql);
            if (inscricoesNoDia != null) {
                int indice = 1;
                Calendar cal = Calendar.getInstance();
                cal.set(Calendar.DAY_OF_MONTH, CFG.DATA_EVENTO_CIAR_DIA);
                cal.set(Calendar.MONTH, (CFG.DATA_EVENTO_CIAR_MES - 1));
                cal.set(Calendar.YEAR, CFG.DATA_EVENTO_CIAR_ANO);
                query.setDate(indice++, new java.sql.Date(cal.getTime().getTime()));
            }
            ResultSet result = query.executeQuery();
            while (result.next()) {
                inscritos.add(new tela.eventociar.Inscrito(
                        result.getString("cpf"),
                        result.getString("nome"),
                        result.getString("email")));

            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public List<tela.eventociar.Inscrito> getInscritosNormalEventoCiar2013() throws SQLException {
        return getInscritosNormalEventoCiar2013(null);
    }

    public List<tela.eventociar.Inscrito> getInscritosNormalNoDiaEventoCiar2013() throws SQLException {
        return getInscritosNormalEventoCiar2013(true);
    }

    public List<tela.eventociar.Inscrito> getInscritosNormalAntesDoEventoCiar2013() throws SQLException {
        return getInscritosNormalEventoCiar2013(false);
    }

    private List<tela.eventociar.Inscrito> getInscritosNormalEventoCiar2013(Boolean inscricoesNoDia) throws SQLException {
        List<tela.eventociar.Inscrito> inscritos = new ArrayList<tela.eventociar.Inscrito>();
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT * FROM inscricoes_evento_ciar_2013_normal ";
            if (inscricoesNoDia != null) {
                if (inscricoesNoDia.booleanValue()) { // Pegar inscrições no dia do evento
                    sql += " WHERE DATE(horario) = ? ";
                } else { // Pegar inscrições antes do evento
                    sql += " WHERE DATE(horario) < ? ";
                }
            }
            PreparedStatement query = conexao.prepareStatement(sql);
            if (inscricoesNoDia != null) {
                int indice = 1;
                Calendar cal = Calendar.getInstance();
                cal.set(Calendar.DAY_OF_MONTH, CFG.DATA_EVENTO_CIAR_DIA);
                cal.set(Calendar.MONTH, (CFG.DATA_EVENTO_CIAR_MES - 1));
                cal.set(Calendar.YEAR, CFG.DATA_EVENTO_CIAR_ANO);
                query.setDate(indice++, new java.sql.Date(cal.getTime().getTime()));
            }
            ResultSet result = query.executeQuery();
            while (result.next()) {
                inscritos.add(new tela.eventociar.Inscrito(
                        result.getString("cpf"),
                        result.getString("nome"),
                        result.getString("email")));

            }
            Conexao.close(conexao, query, result);
            return inscritos;
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }

    public NumeroDeInscritos getTotalInscritosEventoCiar2013() throws SQLException {
        return getTotalInscritosEventoCiar2013(null);
    }

    public NumeroDeInscritos getTotalInscritosNoDiaEventoCiar2013() throws SQLException {
        return getTotalInscritosEventoCiar2013(true);
    }

    public NumeroDeInscritos getTotalInscritosAntesDoEventoCiar2013() throws SQLException {
        return getTotalInscritosEventoCiar2013(false);
    }

    private NumeroDeInscritos getTotalInscritosEventoCiar2013(Boolean inscricoesNoDia) throws SQLException {
        Connection conexao = Conexao.getConexao();
        try {
            String sql = "SELECT COUNT(*) AS total, SUM(IF(vip = true,1,0)) AS total_vip, SUM(IF(vip = false,1,0)) AS total_comum FROM inscricoes_evento_ciar_2013 ";
            if (inscricoesNoDia != null) {
                if (inscricoesNoDia.booleanValue()) { // Pegar inscrições no dia do evento
                    sql += " WHERE DATE(horario) = ? ";
                } else { // Pegar inscrições antes do evento
                    sql += " WHERE DATE(horario) < ? ";
                }
            }
            PreparedStatement query = conexao.prepareStatement(sql);
            if (inscricoesNoDia != null) {
                int indice = 1;
                Calendar cal = Calendar.getInstance();
                cal.set(Calendar.DAY_OF_MONTH, CFG.DATA_EVENTO_CIAR_DIA);
                cal.set(Calendar.MONTH, (CFG.DATA_EVENTO_CIAR_MES - 1));
                cal.set(Calendar.YEAR, CFG.DATA_EVENTO_CIAR_ANO);
                query.setDate(indice++, new java.sql.Date(cal.getTime().getTime()));
            }
            ResultSet result = query.executeQuery();
            if (result.next()) {
                NumeroDeInscritos numeroInscritos = new NumeroDeInscritos(
                        result.getInt("total"),
                        result.getInt("total_vip"),
                        result.getInt("total_comum"));
                Conexao.close(conexao, query, result);
                return numeroInscritos;
            } else {
                Conexao.close(conexao, query, result);
                return new NumeroDeInscritos();
            }
        } catch (SQLException ex) {
            Conexao.close(conexao, ex);
            throw ex;
        }
    }
    //</editor-fold>

    /**
     * *********************************************
     * ********** STRNIGS SQL **********************
     * *********************************************
     */
    //<editor-fold defaultstate="collapsed" desc="Strings SQL.">
    private String getSQLInserirUsuario() {
        StringBuilder s = new StringBuilder();
        s.append("INSERT INTO  usuario (");
        s.append("cpf,");
        s.append("nome,");
        s.append("sobrenome,");
        s.append("nascimento,");
        s.append("sexo,");
        s.append("ensino_medio,");
        s.append("graduacao,");
        s.append("especializacao,");
        s.append("mestrado,");
        s.append("doutorado,");
        s.append("email,");
        s.append("ddd_telefone,");
        s.append("telefone,");
        s.append("senha,");
        s.append("endereco_cep,");
        s.append("endereco_logradouro,");
        s.append("endereco_numero,");
        s.append("endereco_bairro,");
        s.append("endereco_cidade,");
        s.append("endereco_estado, ");
        s.append("estado, ");
        s.append("cidade");
        s.append(") VALUES (");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?,");
        s.append("?");
        s.append(")");
        return s.toString();
    }

    private String getSQLAtualizarEmailUsuario() {
        StringBuilder s = new StringBuilder();
        s.append(" UPDATE usuario SET ");
        s.append(" email = ?");
        s.append(" WHERE cpf = ? ");
        return s.toString();
    }

    private String getSQLAtualizarUsuario() {
        StringBuilder s = new StringBuilder();
        s.append(" UPDATE usuario SET ");
        s.append(" nome = ?, ");
        s.append(" sobrenome = ?,");
        s.append(" nascimento = ?,");
        s.append(" sexo = ?,");
        s.append(" ensino_medio = ?,");
        s.append(" graduacao = ?,");
        s.append(" especializacao = ?,");
        s.append(" mestrado = ?,");
        s.append(" doutorado = ?,");
        s.append(" email = ?,");
        s.append(" ddd_telefone = ?,");
        s.append(" telefone = ?,");
        s.append(" senha = ?,");
        s.append(" endereco_cep = ?,");
        s.append(" endereco_logradouro = ?,");
        s.append(" endereco_numero = ?,");
        s.append(" endereco_bairro = ?,");
        s.append(" endereco_cidade = ?,");
        s.append(" endereco_estado = ?, ");
        s.append(" estado = ?, ");
        s.append(" cidade = ? ");
        s.append(" WHERE cpf = ? ");
        return s.toString();
    }

    private String getSQLCursos() {
        StringBuilder s = new StringBuilder();
        s.append("SELECT ");
        s.append(" inscricao.numero, ");
        s.append(" curso.nome ");
        s.append(" FROM inscricao, ");
        s.append(" curso ");
        s.append(" WHERE ");
        s.append(" inscricao.numero_curso = curso.numero ");
        s.append(" AND inscricao.usuario_cpf = ? ");
        return s.toString();
    }

    private String getSqlUsuario() {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT u.*, fun.funcoes_id, cidade.nome ");
        s.append(" FROM usuario u ");
        s.append(" LEFT OUTER JOIN usuario_is_funcoes fun ON fun.usuario_cpf = u.cpf ");
        s.append(" INNER JOIN cidade ON cidade.id = u.cidade ");
        s.append(" WHERE u.cpf = ? ");
        return s.toString();
    }

    private String getSQLInscritos() {
        StringBuilder s = new StringBuilder();;
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" homologado, ");
        s.append(" usuario.endereco_cidade AS cidade, ");
        s.append(" polo.numero AS polo_numero, ");
        s.append(" polo.nome AS polo_nome, ");
        s.append(" cpf, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" presenca_encontro_presencial,");
        s.append(" numero_curso, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" polo, ");
        s.append(" usuario ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_polo = polo.numero ");
        s.append(" ORDER BY polo_nome, usuario.nome");
        return s.toString();
    }

    private String getSQLInscritosCursoOrientador() {
        StringBuilder s = new StringBuilder();;
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" homologado, ");
        s.append(" usuario.endereco_cidade AS cidade, ");
        s.append(" cidade_sede.numero AS cidade_sede_numero, ");
        s.append(" cidade_sede.nome AS cidade_sede_nome, ");
        s.append(" cpf, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" presenca_encontro_presencial,");
        s.append(" numero_curso, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" cidade_sede, ");
        s.append(" usuario ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_cidade_sede = cidade_sede.numero ");
        s.append(" ORDER BY cidade_sede_nome");
        return s.toString();
    }

    private String getSQLInscritosPorPolo(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" polo.numero AS polo_numero, ");
        s.append(" polo.nome AS polo, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" polo, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_polo = polo.numero ");
        s.append(" AND cidade.id = usuario.cidade ");
        s.append(" AND (homologado = 0 OR homologado = 2)");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLInscritosPorCidadeSede(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" cidade_sede.numero AS cidade_sede_numero, ");
        s.append(" cidade_sede.nome AS cidade_sede, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" cidade_sede, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_cidade_sede = cidade_sede.numero ");
        s.append(" AND cidade.id = usuario.cidade ");
        s.append(" AND (homologado = 0 OR homologado = 2)");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLHomologadosPorCidadeSede(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" CONCAT(usuario.nome,' ',usuario.sobrenome) AS nome, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" cidade_sede.numero AS cidade_sede_numero, ");
        s.append(" cidade_sede.nome AS cidade_sede, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" cidade_sede, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_cidade_sede = cidade_sede.numero ");
        s.append(" AND usuario.cidade = cidade.id ");
        s.append(" AND homologado = 1 ");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLHomologados(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" CONCAT(usuario.nome,' ',usuario.sobrenome) AS nome, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" polo.numero AS polo_numero, ");
        s.append(" polo.nome AS polo, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" polo, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_polo = polo.numero ");
        s.append(" AND usuario.cidade = cidade.id ");
        s.append(" AND homologado = 1 ");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLAprovados(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" CONCAT(usuario.nome,' ',usuario.sobrenome) AS nome, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" polo.numero AS polo_numero, ");
        s.append(" polo.nome AS polo, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" polo, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_polo = polo.numero ");
        s.append(" AND usuario.cidade = cidade.id ");
        s.append(" AND homologado = 1 ");
        s.append(" AND aprovacao = 1 ");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLAprovadosPorCidadeSede(String orderBy) {
        StringBuilder s = new StringBuilder();
        s.append(" SELECT ");
        s.append(" hora, ");
        s.append(" CONCAT(usuario.nome,' ',usuario.sobrenome) AS nome, ");
        s.append(" homologado, ");
        s.append(" cidade.nome AS cidade, ");
        s.append(" cidade_sede.numero AS cidade_sede_numero, ");
        s.append(" cidade_sede.nome AS cidade_sede, ");
        s.append(" usuario.cpf AS usuario_cpf, ");
        s.append(" usuario.nome AS nomeusuario, ");
        s.append(" usuario.sobrenome AS usuario_sobrenome, ");
        s.append(" usuario.email AS usuario_email, ");
        s.append(" inscricao.numero, ");
        s.append(" aprovacao, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" tutor_orientador,");
        s.append(" tutor_orientador AS funcao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido ");
        s.append(" FROM inscricao, ");
        s.append(" cidade_sede, ");
        s.append(" usuario, ");
        s.append(" cidade ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_curso = ? ");
        s.append(" AND inscricao.numero_cidade_sede = cidade_sede.numero ");
        s.append(" AND usuario.cidade = cidade.id ");
        s.append(" AND homologado = 1 ");
        s.append(" AND aprovacao = 1 ");
        s.append(orderBy);
        return s.toString();
    }

    private String getSQLgetInscricaoPorNumero() {
        StringBuilder s = new StringBuilder();
        s.append("SELECT ");
        s.append(" homologado, ");
        s.append(" tutor_orientador, ");
        s.append(" usuario.cpf AS cpf, ");
        s.append(" questao, ");
        s.append(" curriculo, ");
        s.append(" numero_curso, ");
        s.append(" link_lattes, ");
        s.append(" aprovacao, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido, ");
        s.append(" polo.numero AS numero, ");
        s.append(" polo.nome AS nome ");
        s.append(" FROM ");
        s.append(" inscricao, ");
        s.append(" usuario, ");
        s.append(" polo ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_polo = polo.numero ");
        s.append(" AND inscricao.numero = ? ");
        return s.toString();
    }

    private String getSQLgetInscricaoPorNumeroOrientador() {
        StringBuilder s = new StringBuilder();
        s.append("SELECT ");
        s.append(" homologado, ");
        s.append(" tutor_orientador, ");
        s.append(" usuario.cpf AS cpf, ");
        s.append(" questao, ");
        s.append(" curriculo, ");
        s.append(" aprovacao, ");
        s.append(" numero_curso, ");
        s.append(" link_lattes, ");
        s.append(" recurso, ");
        s.append(" recurso_texto, ");
        s.append(" recurso_indeferido, ");
        s.append(" cidade_sede.numero AS numero, ");
        s.append(" cidade_sede.nome AS nome ");
        s.append(" FROM ");
        s.append(" inscricao, ");
        s.append(" usuario, ");
        s.append(" cidade_sede ");
        s.append(" WHERE ");
        s.append(" inscricao.usuario_cpf = usuario.cpf ");
        s.append(" AND inscricao.numero_cidade_sede = cidade_sede.numero ");
        s.append(" AND inscricao.numero = ? ");
        return s.toString();
    }

    private String getSQLPolosPorCurso() {
        StringBuilder s = new StringBuilder();
        s.append("SELECT ");
        s.append(" polo.numero AS numero, ");
        s.append(" polo.nome AS nome ");
        s.append(" FROM curso_em_polo, polo ");
        s.append(" WHERE ");
        s.append(" numero_curso = ? ");
        s.append(" AND curso_em_polo.numero_polo = polo.numero ");
        s.append(" ORDER BY polo.nome");
        return s.toString();
    }

    private String getSQLCidadesSedePorCurso() {
        StringBuilder s = new StringBuilder();
        s.append("SELECT ");
        s.append(" cidade_sede.numero AS numero, ");
        s.append(" cidade_sede.nome AS nome ");
        s.append(" FROM curso_em_cidade_sede, cidade_sede ");
        s.append(" WHERE ");
        s.append(" numero_curso = ? ");
        s.append(" AND curso_em_cidade_sede.numero_cidade = cidade_sede.numero ");
        s.append(" ORDER BY cidade_sede.nome");
        return s.toString();
    }

    private String getSQLInserirInscricaoOrientador() {
        StringBuilder s = new StringBuilder();
        s.append("INSERT INTO inscricao (");
        s.append(" aprovacao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" numero_curso, ");
        s.append(" numero_cidade_sede, ");
        s.append(" tutor_orientador, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" usuario_cpf, ");
        s.append(" escolaridade, ");
        s.append(" link_lattes ");
        s.append(" ) VALUES ( ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ? ");
        s.append(" ) ");
        return s.toString();
    }

    private String getSQLInserirInscricao() {
        StringBuilder s = new StringBuilder();
        s.append("INSERT INTO inscricao (");
        s.append(" aprovacao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" numero_curso, ");
        s.append(" numero_polo, ");
        s.append(" tutor_orientador, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" usuario_cpf, ");
        s.append(" escolaridade, ");
        s.append(" link_lattes ");
        s.append(" ) VALUES ( ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ? ");
        s.append(" ) ");
        return s.toString();
    }

    private String getSQLInserirInscricaoAluno() {
        StringBuilder s = new StringBuilder();
        s.append("INSERT INTO inscricao (");
        s.append(" aprovacao, ");
        s.append(" presenca_encontro_presencial, ");
        s.append(" numero_curso, ");
        s.append(" numero_polo, ");
        s.append(" curriculo, ");
        s.append(" questao, ");
        s.append(" usuario_cpf, ");
        s.append(" link_lattes ");
        s.append(" ) VALUES ( ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ? ");
        s.append(" ) ");
        return s.toString();
    }

    private String getSQLInserirCurso() {
        StringBuilder s = new StringBuilder();
        s.append("INSERT INTO curso ( ");
        s.append(" nome, ");
        s.append(" carga_horaria, ");
        s.append(" inicio_inscricao, ");
        s.append(" fim_inscricao, ");
        s.append(" questao, ");
        s.append(" tipo, ");
        s.append(" modelo_certificado, ");
        s.append(" tipo_vaga, ");
        s.append(" min_caracteres_questao, ");
        s.append(" max_caracteres_questao, ");
        s.append(" homologacao_preliminar, ");
        s.append(" homologacao_final, ");
        s.append(" recurso_inicio, ");
        s.append(" recurso_fim ");
        s.append(" ) VALUES ( ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ?, ");
        s.append(" ? ");
        s.append(" ) ");
        return s.toString();
    }
    //</editor-fold>
}
